Processing data associated with different tenant identifiers

ABSTRACT

Systems and methods are described for processing incoming data. The system can receive, from a first partition manager of a data intake and query system, first data that is associated with a first identifier, and can receive, from a second partition manager of the data intake and query system, second data that is associated with a second identifier. The system can process the first data and store first results of said processing the first data in one or more first buckets associated with the first tenant identifier. The system can process the second data and store second results of said processing the second data in one or more second buckets associated with the second tenant identifier.

RELATED APPLICATIONS

Any and all applications for which a foreign or domestic priority claimis identified in the Application Data Sheet as filed with the presentapplication are incorporated by reference under 37 CFR 1.57 and made apart of this specification. This application also incorporates byreference U.S. application Ser. Nos. 16/264,019; 16/147,129; 15/967,587;16/264,299; 15/665,159; 15/665,148; 15/665,187; 15/665,248; 15/665,197;15/665,279; 15/665,302; 15/665,339; and Ser. No. 15/276,717, in theirentirety. In addition, this application is being filed on Jul. 16, 2019concurrently with the following U.S. Patent Applications, each of whichis incorporated by reference herein in its entirety:

Patent Application Title Filing Date 16/513,365 IDENTIFYING AN INDEXINGNODE TO Jul. 16, 2019 PROCESS DATA USING A RESOURCE CATALOG 16/513,378PROCESSING DATA ASSOCIATED WITH DIFFERENT TENANT Jul. 16, 2019IDENTIFIERS 16/513,555 DYNAMICALLY ASSIGNING A Jul. 16, 2019 SEARCH HEADAND SEARCH NODES FOR A QUERY 16/513,546 MAPPING SEARCH NODES TO A Jul.16, 2019 SEARCH HEAD USING A TENANT IDENTIFIER 16/512,899 AUTHENTICATINGA USER TO ACCESS Jul. 16, 2019 A DATA INTAKE AND QUERY SYSTEM

FIELD

At least one embodiment of the present disclosure pertains to one ormore tools for facilitating searching and analyzing large sets of datato locate data of interest.

BACKGROUND

Information technology (IT) environments can include diverse types ofdata systems that store large amounts of diverse data types generated bynumerous devices. For example, a big data ecosystem may includedatabases such as MySQL and Oracle databases, cloud computing servicessuch as Amazon web services (AWS), and other data systems that storepassively or actively generated data, including machine-generated data(“machine data”). The machine data can include performance data,diagnostic data, or any other data that can be analyzed to diagnoseequipment performance problems, monitor user interactions, and to deriveother insights.

The large amount and diversity of data systems containing large amountsof structured, semi-structured, and unstructured data relevant to anysearch query can be massive, and continues to grow rapidly. Thistechnological evolution can give rise to various challenges in relationto managing, understanding and effectively utilizing the data. To reducethe potentially vast amount of data that may be generated, some datasystems pre-process data based on anticipated data analysis needs. Inparticular, specified data items may be extracted from the generateddata and stored in a data system to facilitate efficient retrieval andanalysis of those data items at a later time. At least some of theremainder of the generated data is typically discarded duringpre-processing.

However, storing massive quantities of minimally processed orunprocessed data (collectively and individually referred to as “rawdata”) for later retrieval and analysis is becoming increasingly morefeasible as storage capacity becomes more inexpensive and plentiful. Ingeneral, storing raw data and performing analysis on that data later canprovide greater flexibility because it enables an analyst to analyze allof the generated data instead of only a fraction of it.

Although the availability of vastly greater amounts of diverse data ondiverse data systems provides opportunities to derive new insights, italso gives rise to technical challenges to search and analyze the data.Tools exist that allow an analyst to search data systems separately andcollect results over a network for the analyst to derive insights in apiecemeal manner. However, UI tools that allow analysts to quicklysearch and analyze large set of raw machine data to visually identifydata subsets of interest, particularly via straightforward andeasy-to-understand sets of tools and search functionality do not exist.

BRIEF DESCRIPTION OF THE DRAWINGS

The present disclosure is illustrated by way of example, and notlimitation, in the figures of the accompanying drawings, in which likereference numerals indicate similar elements.

FIG. 1 is a block diagram of an example networked computer environment,in accordance with example embodiments.

FIG. 2A is a block diagram of an example data intake and query system,in accordance with example embodiments.

FIG. 2B is a flow diagram illustrative of an embodiment of a routine toenable a user access to one or more components of the data intake andquery system.

FIG. 3A is a block diagram of one embodiment an intake system.

FIG. 3B is a block diagram of another embodiment of an intake system.

FIG. 4A is a block diagram illustrating an embodiment of an indexingsystem of the data intake and query system.

FIG. 4B is a block diagram illustrating an embodiment of an indexingsystem of the data intake and query system.

FIG. 5 is a block diagram illustrating an embodiment of a query systemof the data intake and query system.

FIG. 6 is a block diagram illustrating an embodiment of a metadatacatalog.

FIG. 7 is a data flow diagram depicting illustrative interactions forprocessing data through an intake system, in accordance with exampleembodiments.

FIG. 8 is a flow diagram depicting an illustrative routine forprocessing data at an intake system, according to example embodiments.

FIG. 9 is a data flow diagram illustrating an embodiment of the dataflow and communications between a variety of the components of the dataintake and query system during indexing.

FIG. 10A is a flow diagram illustrative of an embodiment of a routineimplemented by an indexing system to store data in common storage.

FIG. 10B is a flow diagram illustrative of an embodiment of a routineimplemented by an indexing system to store data in common storage.

FIG. 10C is a flow diagram illustrative of an embodiment of a routineimplemented by an indexing node to update a location marker in aningestion buffer.

FIG. 10D is a flow diagram illustrative of an embodiment of a routineimplemented by an indexing node to merge buckets.

FIG. 10E is a flow diagram illustrative of an embodiment of a routine toassign or map an indexing node to process data.

FIG. 10F is a flow diagram illustrative of an embodiment of a routine toprocess incoming data.

FIG. 10G is a flow diagram illustrative of an embodiment of a routine toprocess incoming data.

FIG. 11 is a data flow diagram illustrating an embodiment of the dataflow and communications between a variety of the components of the dataintake and query system during execution of a query.

FIG. 12A is a flow diagram illustrative of an embodiment of a routineimplemented by a query system to execute a query.

FIG. 12B is a flow diagram illustrative of an embodiment of a routineimplemented by a query system to execute a query.

FIG. 12C is a flow diagram illustrative of an embodiment of a routineimplemented by a query system to identify buckets for query execution.

FIG. 12D is a flow diagram illustrative of an embodiment of a routineimplemented by a query system to identify search nodes for queryexecution.

FIG. 12E is a flow diagram illustrative of an embodiment of a routineimplemented by a query system to hash bucket identifiers for queryexecution.

FIG. 12F is a flow diagram illustrative of an embodiment of a routineimplemented by a search node to execute a search on a bucket.

FIG. 12G is a flow diagram illustrative of an embodiment of a routineimplemented by the query system to store search results.

FIG. 12H is a flow diagram illustrative of an embodiment of a routine toexecute a query.

FIG. 12I is a flow diagram illustrative of an embodiment of a routine toidentify search heads for query processing.

FIG. 12J is a flow diagram illustrative of an embodiment of a routine tomap search nodes to a search head.

FIG. 13 is a data flow diagram illustrating an embodiment of the dataflow and communications between a variety of the components of the dataintake and query system to execute a query.

FIG. 14 is a data flow diagram illustrating an embodiment of the dataflow for identifying query datasets and query configuration parametersfor a particular query.

FIG. 15A is a flow diagram illustrative of an embodiment of a routineimplemented by the query system to execute a query.

FIG. 15B is a flow diagram illustrative of an embodiment of a routineimplemented by a query system manager to communicate query configurationparameters to a query processing component.

FIG. 15C is a flow diagram illustrative of an embodiment of a routineimplemented by the query system to execute a query.

FIG. 15D is a flow diagram illustrative of an embodiment of a routineimplemented by the query system to execute a query.

FIG. 15E is a flow diagram illustrative of an embodiment of a routineimplemented by the query system to execute a query.

FIG. 15F is a flow diagram illustrative of an embodiment of a routineimplemented by the system to generate annotations by parsing a query.

FIG. 15G is a flow diagram illustrative of an embodiment of a routineimplemented by the system to generate annotations based on changes to ametadata catalog.

FIG. 16A is a flow diagram of an example method that illustrates howindexers process, index, and store data received from intake system, inaccordance with example embodiments.

FIG. 16B is a block diagram of a data structure in which time-stampedevent data can be stored in a data store, in accordance with exampleembodiments.

FIG. 16C provides a visual representation of the manner in which apipelined search language or query operates, in accordance with exampleembodiments.

FIG. 17A is a flow diagram of an example method that illustrates how asearch head and indexers perform a search query, in accordance withexample embodiments.

FIG. 17B provides a visual representation of an example manner in whicha pipelined command language or query operates, in accordance withexample embodiments.

FIG. 18A is a diagram of an example scenario where a common customeridentifier is found among log data received from three disparate datasources, in accordance with example embodiments.

FIG. 18B illustrates an example of processing keyword searches and fieldsearches, in accordance with disclosed embodiments.

FIG. 18C illustrates an example of creating and using an inverted index,in accordance with example embodiments.

FIG. 18D depicts a flowchart of example use of an inverted index in apipelined search query, in accordance with example embodiments.

FIG. 19A is an interface diagram of an example user interface for asearch screen, in accordance with example embodiments.

FIG. 19B is an interface diagram of an example user interface for a datasummary dialog that enables a user to select various data sources, inaccordance with example embodiments.

FIGS. 20, 21, 22A, 22B, 22C, 22D, 23, 24, 25, and 26 are interfacediagrams of example report generation user interfaces, in accordancewith example embodiments.

FIG. 27 is an example search query received from a client and executedby search peers, in accordance with example embodiments.

FIG. 28A is an interface diagram of an example user interface of a keyindicators view, in accordance with example embodiments.

FIG. 28B is an interface diagram of an example user interface of anincident review dashboard, in accordance with example embodiments.

FIG. 28C is a tree diagram of an example a proactive monitoring tree, inaccordance with example embodiments.

FIG. 28D is an interface diagram of an example a user interfacedisplaying both log data and performance data, in accordance withexample embodiments.

DETAILED DESCRIPTION

Embodiments are described herein according to the following outline:

1.0. General Overview 2.0. Operating Environment 2.1. Host Devices 2.2.Client Devices 2.3. Client Device Applications 2.4. Data Intake andQuery System Overview 3.0. Data Intake and Query System Architecture 3.1Gateway and Authentication Flow 3.2. Intake System 3.2.1 Forwarder 3.2.2Data Retrieval Subsystem 3.2.3 Ingestion Buffer 3.2.4 Streaming DataProcessors 3.3. Indexing System 3.3.1. Indexing System Manager 3.3.2.Indexing Nodes 3.3.2.1 Ingest Manager 3.3.2.2 Partition Manager 3.3.2.3Indexer and Data Store 3.3.3. Bucket Manager 3.4 Query System 3.4.1.Query System Manager 3.4.2. Search Head 3.4.2.1 Search Master 3.4.2.2Search Manager 3.4.3. Search Nodes 3.4.4. Cache Manager 3.4.5. ResourceMonitor and Catalog 3.5. Common Storage 3.6. Data Store Catalog 3.7.Query Acceleration Data Store 3.8. Metadata Catalog 3.8.1. DatasetAssociation Records 3.8.2. Dataset Configuration Records 3.8.3. RuleConfiguration Records 3.8.4. Annotations 3.8.4.1. Generating Annotations3.8.4.1.1. System Annotations Based on System Use 3.8.4.1.1.1. QueryParsing 3.8.4.1.1.2. Query Execution 3.8.4.1.1.3. User Monitoring3.8.4.1.1.4. Application Monitoring 3.8.4.1.2. System Annotations Basedon Metadata Catalog Changes 3.8.4.2. Example Annotations 3.8.4.2.1.Field Annotations 3.8.4.2.2. Inter-Field Relationship Annotations3.8.4.2.3. Inter-Dataset Relationship Annotations 3.8.4.2.4. Datasetproperties Annotations 3.8.4.2.5. Normalization Annotations 3.8.4.2.6.Unit Annotations 3.8.4.2.7. Alarm Threshold Annotations 3.8.4.2.8. DataCategory Annotations 3.8.4.2.9. User/Group Annotations 3.8.4.2.10.Application Annotations 4.0. Data Intake and Query System Functions 4.1.Intake 4.1.1 Publication to Intake Topic(s) 4.1.2 Transmission toStreaming Data Processors 4.1.3 Messages Processing 4.1.4 Transmissionto Subscribers 4.1.5 Data Resiliency and Security 4.1.6 MessageProcessing Algorithm 4.2. Indexing 4.2.1. Containerized Indexing Nodes4.2.2. Moving Buckets to Common Storage 4.2.3. Updating Location Markerin Ingestion Buffer 4.2.4. Merging Buckets 4.3. Querying 4.3.1.Containerized Search Nodes 4.3.2. Identifying Buckets for QueryExecution 4.3.4. Hashing Bucket Identifiers for Query Execution 4.3.5.Mapping Buckets to Search Nodes 4.3.6. Obtaining Data for QueryExecution 4.3.7. Caching Search Results 4.4. Querying Using MetadataCatalog 4.4.1. Metadata Catalog Data Flow 4.4.2. Example MetadataCatalog Processing 4.4.3. Metadata Catalog Flows 4.5 Annotating theMetadata Catalog 4.5.1 Annotations Based on System Use Flow 4.5.2Annotations Based on Catalog Changes Flow 4.6. Data Ingestion, Indexing,and Storage Flow 4.6.1. Input 4.6.2. Parsing 4.6.3. Indexing 4.7. QueryProcessing Flow 4.8. Pipelined Search Language 4.9. Field Extraction4.10. Example Search Screen 4.11. Data Models 4.12. AccelerationTechniques 4.12.1. Aggregation Technique 4.12.2. Keyword Index 4.12.3.High Performance Analytics Store 4.10.3.1 Extracting Event Data UsingPosting 4.12.4. Accelerating Report Generation 4.13. Security Features4.14. Data Center Monitoring 4.15. IT Service Monitoring 4.16. OtherArchitectures 5.0. Example Embodiments 6.0. Terminology

1.0. General Overview

Modern data centers and other computing environments can compriseanywhere from a few host computer systems to thousands of systemsconfigured to process data, service requests from remote clients, andperform numerous other computational tasks. During operation, variouscomponents within these computing environments often generatesignificant volumes of machine data. Machine data is any data producedby a machine or component in an information technology (IT) environmentand that reflects activity in the IT environment. For example, machinedata can be raw machine data that is generated by various components inIT environments, such as servers, sensors, routers, mobile devices,Internet of Things (IoT) devices, etc. Machine data can include systemlogs, network packet data, sensor data, application program data, errorlogs, stack traces, system performance data, etc. In general, machinedata can also include performance data, diagnostic information, and manyother types of data that can be analyzed to diagnose performanceproblems, monitor user interactions, and to derive other insights.

A number of tools are available to analyze machine data. In order toreduce the size of the potentially vast amount of machine data that maybe generated, many of these tools typically pre-process the data basedon anticipated data-analysis needs. For example, pre-specified dataitems may be extracted from the machine data and stored in a database tofacilitate efficient retrieval and analysis of those data items atsearch time. However, the rest of the machine data typically is notsaved and is discarded during pre-processing. As storage capacitybecomes progressively cheaper and more plentiful, there are fewerincentives to discard these portions of machine data and many reasons toretain more of the data.

This plentiful storage capacity is presently making it feasible to storemassive quantities of minimally processed machine data for laterretrieval and analysis. In general, storing minimally processed machinedata and performing analysis operations at search time can providegreater flexibility because it enables an analyst to search all of themachine data, instead of searching only a pre-specified set of dataitems. This may enable an analyst to investigate different aspects ofthe machine data that previously were unavailable for analysis.

However, analyzing and searching massive quantities of machine datapresents a number of challenges. For example, a data center, servers, ornetwork appliances may generate many different types and formats ofmachine data (e.g., system logs, network packet data (e.g., wire data,etc.), sensor data, application program data, error logs, stack traces,system performance data, operating system data, virtualization data,etc.) from thousands of different components, which can collectively bevery time-consuming to analyze. In another example, mobile devices maygenerate large amounts of information relating to data accesses,application performance, operating system performance, networkperformance, etc. There can be millions of mobile devices that reportthese types of information.

These challenges can be addressed by using an event-based data intakeand query system, such as the SPLUNK® ENTERPRISE system developed bySplunk Inc. of San Francisco, Calif. The SPLUNK® ENTERPRISE system isthe leading platform for providing real-time operational intelligencethat enables organizations to collect, index, and search machine datafrom various websites, applications, servers, networks, and mobiledevices that power their businesses. The data intake and query system isparticularly useful for analyzing data which is commonly found in systemlog files, network data, and other data input sources. Although many ofthe techniques described herein are explained with reference to a dataintake and query system similar to the SPLUNK® ENTERPRISE system, thesetechniques are also applicable to other types of data systems.

In the data intake and query system, machine data are collected andstored as “events”. An event comprises a portion of machine data and isassociated with a specific point in time. The portion of machine datamay reflect activity in an IT environment and may be produced by acomponent of that IT environment, where the events may be searched toprovide insight into the IT environment, thereby improving theperformance of components in the IT environment. Events may be derivedfrom “time series data,” where the time series data comprises a sequenceof data points (e.g., performance measurements from a computer system,etc.) that are associated with successive points in time. In general,each event has a portion of machine data that is associated with atimestamp that is derived from the portion of machine data in the event.A timestamp of an event may be determined through interpolation betweentemporally proximate events having known timestamps or may be determinedbased on other configurable rules for associating timestamps withevents.

In some instances, machine data can have a predefined format, where dataitems with specific data formats are stored at predefined locations inthe data. For example, the machine data may include data associated withfields in a database table. In other instances, machine data may nothave a predefined format (e.g., may not be at fixed, predefinedlocations), but may have repeatable (e.g., non-random) patterns. Thismeans that some machine data can comprise various data items ofdifferent data types that may be stored at different locations withinthe data. For example, when the data source is an operating system log,an event can include one or more lines from the operating system logcontaining machine data that includes different types of performance anddiagnostic information associated with a specific point in time (e.g., atimestamp).

Examples of components which may generate machine data from which eventscan be derived include, but are not limited to, web servers, applicationservers, databases, firewalls, routers, operating systems, and softwareapplications that execute on computer systems, mobile devices, sensors,Internet of Things (IoT) devices, etc. The machine data generated bysuch data sources can include, for example and without limitation,server log files, activity log files, configuration files, messages,network packet data, performance measurements, sensor measurements, etc.

The data intake and query system uses a flexible schema to specify howto extract information from events. A flexible schema may be developedand redefined as needed. Note that a flexible schema may be applied toevents “on the fly,” when it is needed (e.g., at search time, indextime, ingestion time, etc.). When the schema is not applied to eventsuntil search time, the schema may be referred to as a “late-bindingschema.”

During operation, the data intake and query system receives machine datafrom any type and number of sources (e.g., one or more system logs,streams of network packet data, sensor data, application program data,error logs, stack traces, system performance data, etc.). The systemparses the machine data to produce events each having a portion ofmachine data associated with a timestamp. The system stores the eventsin a data store. The system enables users to run queries against thestored events to, for example, retrieve events that meet criteriaspecified in a query, such as criteria indicating certain keywords orhaving specific values in defined fields. As used herein, the term“field” refers to a location in the machine data of an event containingone or more values for a specific data item. A field may be referencedby a field name associated with the field. As will be described in moredetail herein, a field is defined by an extraction rule (e.g., a regularexpression) that derives one or more values or a sub-portion of textfrom the portion of machine data in each event to produce a value forthe field for that event. The set of values produced aresemantically-related (such as IP address), even though the machine datain each event may be in different formats (e.g., semantically-relatedvalues may be in different positions in the events derived fromdifferent sources).

As described above, the system stores the events in a data store. Theevents stored in the data store are field-searchable, wherefield-searchable herein refers to the ability to search the machine data(e.g., the raw machine data) of an event based on a field specified insearch criteria. For example, a search having criteria that specifies afield name “UserID” may cause the system to field-search the machinedata of events to identify events that have the field name “UserID.” Inanother example, a search having criteria that specifies a field name“UserID” with a corresponding field value “12345” may cause the systemto field-search the machine data of events to identify events havingthat field-value pair (e.g., field name “UserID” with a correspondingfield value of “12345”). Events are field-searchable using one or moreconfiguration files associated with the events. Each configuration fileincludes one or more field names, where each field name is associatedwith a corresponding extraction rule and a set of events to which thatextraction rule applies. The set of events to which an extraction ruleapplies may be identified by metadata associated with the set of events.For example, an extraction rule may apply to a set of events that areeach associated with a particular host, source, or source type. Whenevents are to be searched based on a particular field name specified ina search, the system uses one or more configuration files to determinewhether there is an extraction rule for that particular field name thatapplies to each event that falls within the criteria of the search. Ifso, the event is considered as part of the search results (andadditional processing may be performed on that event based on criteriaspecified in the search). If not, the next event is similarly analyzed,and so on.

As noted above, the data intake and query system utilizes a late-bindingschema while performing queries on events. One aspect of a late-bindingschema is applying extraction rules to events to extract values forspecific fields during search time. More specifically, the extractionrule for a field can include one or more instructions that specify howto extract a value for the field from an event. An extraction rule cangenerally include any type of instruction for extracting values fromevents. In some cases, an extraction rule comprises a regularexpression, where a sequence of characters form a search pattern. Anextraction rule comprising a regular expression is referred to herein asa regex rule. The system applies a regex rule to an event to extractvalues for a field associated with the regex rule, where the values areextracted by searching the event for the sequence of characters definedin the regex rule.

In the data intake and query system, a field extractor may be configuredto automatically generate extraction rules for certain fields in theevents when the events are being created, indexed, or stored, orpossibly at a later time. Alternatively, a user may manually defineextraction rules for fields using a variety of techniques. In contrastto a conventional schema for a database system, a late-binding schema isnot defined at data ingestion time. Instead, the late-binding schema canbe developed on an ongoing basis until the time a query is actuallyexecuted. This means that extraction rules for the fields specified in aquery may be provided in the query itself, or may be located duringexecution of the query. Hence, as a user learns more about the data inthe events, the user can continue to refine the late-binding schema byadding new fields, deleting fields, or modifying the field extractionrules for use the next time the schema is used by the system. Becausethe data intake and query system maintains the underlying machine dataand uses a late-binding schema for searching the machine data, itenables a user to continue investigating and learn valuable insightsabout the machine data.

In some embodiments, a common field name may be used to reference two ormore fields containing equivalent and/or similar data items, even thoughthe fields may be associated with different types of events thatpossibly have different data formats and different extraction rules. Byenabling a common field name to be used to identify equivalent and/orsimilar fields from different types of events generated by disparatedata sources, the system facilitates use of a “common information model”(CIM) across the disparate data sources (further discussed with respectto FIG. 19A).

In some embodiments, the configuration files and/or extraction rulesdescribed above can be stored in a catalog, such as a metadata catalog.In certain embodiments, the content of the extraction rules can bestored as rules or actions in the metadata catalog. For example, theidentification of the data to which the extraction rule applies can bereferred to a rule and the processing of the data can be referred to asan action.

2.0. Operating Environment

FIG. 1 is a block diagram of an example networked computer environment100, in accordance with example embodiments. It will be understood thatFIG. 1 represents one example of a networked computer system and otherembodiments may use different arrangements.

The networked computer environment 100 comprises one or more computingdevices. These one or more computing devices comprise any combination ofhardware and software configured to implement the various logicalcomponents described herein. For example, the one or more computingdevices may include one or more memories that store instructions forimplementing the various components described herein, one or morehardware processors configured to execute the instructions stored in theone or more memories, and various data repositories in the one or morememories for storing data structures utilized and manipulated by thevarious components.

In some embodiments, one or more client devices 102 are coupled to oneor more host devices 106 and a data intake and query system 108 via oneor more networks 104. Networks 104 broadly represent one or more LANs,WANs, cellular networks (e.g., LTE, HSPA, 3G, and other cellulartechnologies), and/or networks using any of wired, wireless, terrestrialmicrowave, or satellite links, and may include the public Internet.

2.1. Host Devices

In the illustrated embodiment, the environment 100 includes one or morehost devices 106. Host devices 106 may broadly include any number ofcomputers, virtual machine instances, and/or data centers that areconfigured to host or execute one or more instances of host applications114. In general, a host device 106 may be involved, directly orindirectly, in processing requests received from client devices 102.Each host device 106 may comprise, for example, one or more of a networkdevice, a web server, an application server, a database server, etc. Acollection of host devices 106 may be configured to implement anetwork-based service. For example, a provider of a network-basedservice may configure one or more host devices 106 and host applications114 (e.g., one or more web servers, application servers, databaseservers, etc.) to collectively implement the network-based application.

In general, client devices 102 communicate with one or more hostapplications 114 to exchange information. The communication between aclient device 102 and a host application 114 may, for example, be basedon the Hypertext Transfer Protocol (HTTP) or any other network protocol.Content delivered from the host application 114 to a client device 102may include, for example, HTML documents, media content, etc. Thecommunication between a client device 102 and host application 114 mayinclude sending various requests and receiving data packets. Forexample, in general, a client device 102 or application running on aclient device may initiate communication with a host application 114 bymaking a request for a specific resource (e.g., based on an HTTPrequest), and the application server may respond with the requestedcontent stored in one or more response packets.

In the illustrated embodiment, one or more of host applications 114 maygenerate various types of performance data during operation, includingevent logs, network data, sensor data, and other types of machine data.For example, a host application 114 comprising a web server may generateone or more web server logs in which details of interactions between theweb server and any number of client devices 102 is recorded. As anotherexample, a host device 106 comprising a router may generate one or morerouter logs that record information related to network traffic managedby the router. As yet another example, a host application 114 comprisinga database server may generate one or more logs that record informationrelated to requests sent from other host applications 114 (e.g., webservers or application servers) for data managed by the database server.

2.2. Client Devices

Client devices 102 of FIG. 1 represent any computing device capable ofinteracting with one or more host devices 106 via a network 104.Examples of client devices 102 may include, without limitation, smartphones, tablet computers, handheld computers, wearable devices, laptopcomputers, desktop computers, servers, portable media players, gamingdevices, and so forth. In general, a client device 102 can provideaccess to different content, for instance, content provided by one ormore host devices 106, etc. Each client device 102 may comprise one ormore client applications 110, described in more detail in a separatesection hereinafter.

2.3. Client Device Applications

In some embodiments, each client device 102 may host or execute one ormore client applications 110 that are capable of interacting with one ormore host devices 106 via one or more networks 104. For instance, aclient application 110 may be or comprise a web browser that a user mayuse to navigate to one or more websites or other resources provided byone or more host devices 106. As another example, a client application110 may comprise a mobile application or “app.” For example, an operatorof a network-based service hosted by one or more host devices 106 maymake available one or more mobile apps that enable users of clientdevices 102 to access various resources of the network-based service. Asyet another example, client applications 110 may include backgroundprocesses that perform various operations without direct interactionfrom a user. A client application 110 may include a “plug-in” or“extension” to another application, such as a web browser plug-in orextension.

In some embodiments, a client application 110 may include a monitoringcomponent 112. At a high level, the monitoring component 112 comprises asoftware component or other logic that facilitates generatingperformance data related to a client device's operating state, includingmonitoring network traffic sent and received from the client device andcollecting other device and/or application-specific information.Monitoring component 112 may be an integrated component of a clientapplication 110, a plug-in, an extension, or any other type of add-oncomponent. Monitoring component 112 may also be a stand-alone process.

In some embodiments, a monitoring component 112 may be created when aclient application 110 is developed, for example, by an applicationdeveloper using a software development kit (SDK). The SDK may includecustom monitoring code that can be incorporated into the codeimplementing a client application 110. When the code is converted to anexecutable application, the custom code implementing the monitoringfunctionality can become part of the application itself.

In some embodiments, an SDK or other code for implementing themonitoring functionality may be offered by a provider of a data intakeand query system, such as a system 108. In such cases, the provider ofthe system 108 can implement the custom code so that performance datagenerated by the monitoring functionality is sent to the system 108 tofacilitate analysis of the performance data by a developer of the clientapplication or other users.

In some embodiments, the custom monitoring code may be incorporated intothe code of a client application 110 in a number of different ways, suchas the insertion of one or more lines in the client application codethat call or otherwise invoke the monitoring component 112. As such, adeveloper of a client application 110 can add one or more lines of codeinto the client application 110 to trigger the monitoring component 112at desired points during execution of the application. Code thattriggers the monitoring component may be referred to as a monitortrigger. For instance, a monitor trigger may be included at or near thebeginning of the executable code of the client application 110 such thatthe monitoring component 112 is initiated or triggered as theapplication is launched, or included at other points in the code thatcorrespond to various actions of the client application, such as sendinga network request or displaying a particular interface.

In some embodiments, the monitoring component 112 may monitor one ormore aspects of network traffic sent and/or received by a clientapplication 110. For example, the monitoring component 112 may beconfigured to monitor data packets transmitted to and/or from one ormore host applications 114. Incoming and/or outgoing data packets can beread or examined to identify network data contained within the packets,for example, and other aspects of data packets can be analyzed todetermine a number of network performance statistics. Monitoring networktraffic may enable information to be gathered particular to the networkperformance associated with a client application 110 or set ofapplications.

In some embodiments, network performance data refers to any type of datathat indicates information about the network and/or network performance.Network performance data may include, for instance, a URL requested, aconnection type (e.g., HTTP, HTTPS, etc.), a connection start time, aconnection end time, an HTTP status code, request length, responselength, request headers, response headers, connection status (e.g.,completion, response time(s), failure, etc.), and the like. Uponobtaining network performance data indicating performance of thenetwork, the network performance data can be transmitted to a dataintake and query system 108 for analysis.

Upon developing a client application 110 that incorporates a monitoringcomponent 112, the client application 110 can be distributed to clientdevices 102. Applications generally can be distributed to client devices102 in any manner, or they can be pre-loaded. In some cases, theapplication may be distributed to a client device 102 via an applicationmarketplace or other application distribution system. For instance, anapplication marketplace or other application distribution system mightdistribute the application to a client device based on a request fromthe client device to download the application.

Examples of functionality that enables monitoring performance of aclient device are described in U.S. patent application Ser. No.14/524,748, entitled “UTILIZING PACKET HEADERS TO MONITOR NETWORKTRAFFIC IN ASSOCIATION WITH A CLIENT DEVICE”, filed on 27 Oct. 2014, andwhich is hereby incorporated by reference in its entirety for allpurposes.

In some embodiments, the monitoring component 112 may also monitor andcollect performance data related to one or more aspects of theoperational state of a client application 110 and/or client device 102.For example, a monitoring component 112 may be configured to collectdevice performance information by monitoring one or more client deviceoperations, or by making calls to an operating system and/or one or moreother applications executing on a client device 102 for performanceinformation. Device performance information may include, for instance, acurrent wireless signal strength of the device, a current connectiontype and network carrier, current memory performance information, ageographic location of the device, a device orientation, and any otherinformation related to the operational state of the client device.

In some embodiments, the monitoring component 112 may also monitor andcollect other device profile information including, for example, a typeof client device, a manufacturer, and model of the device, versions ofvarious software applications installed on the device, and so forth.

In general, a monitoring component 112 may be configured to generateperformance data in response to a monitor trigger in the code of aclient application 110 or other triggering application event, asdescribed above, and to store the performance data in one or more datarecords. Each data record, for example, may include a collection offield-value pairs, each field-value pair storing a particular item ofperformance data in association with a field for the item. For example,a data record generated by a monitoring component 112 may include a“networkLatency” field (not shown in the Figure) in which a value isstored. This field indicates a network latency measurement associatedwith one or more network requests. The data record may include a “state”field to store a value indicating a state of a network connection, andso forth for any number of aspects of collected performance data.

2.4. Data Intake and Query System Overview

The data intake and query system 108 can process and store data receiveddata from the data sources client devices 102 or host devices 106, andexecute queries on the data in response to requests received from one ormore computing devices. In some cases, the data intake and query system108 can generate events from the received data and store the events inbuckets in a common storage system. In response to received queries, thedata intake and query system can assign one or more search nodes tosearch the buckets in the common storage.

In certain embodiments, the data intake and query system 108 can includevarious components that enable it to provide stateless services orenable it to recover from an unavailable or unresponsive componentwithout data loss in a time efficient manner. For example, the dataintake and query system 108 can store contextual information about itsvarious components in a distributed way such that if one of thecomponents becomes unresponsive or unavailable, the data intake andquery system 108 can replace the unavailable component with a differentcomponent and provide the replacement component with the contextualinformation. In this way, the data intake and query system 108 canquickly recover from an unresponsive or unavailable component whilereducing or eliminating the loss of data that was being processed by theunavailable component.

In some embodiments, the data intake and query system 108 can store thecontextual information in a metadata catalog, as described herein. Incertain embodiments, the contextual information can correspond toinformation that the data intake and query system 108 has determined orlearned based on use. In some cases, the contextual information can bestored as annotations (manual annotations and/or system annotations), asdescribed herein.

2.5 on-Premise and Shared Computing Resource Environments

In some environments, a user of a data intake and query system 108 mayinstall and configure, on computing devices owned and operated by theuser, one or more software applications that implement some or all ofthe components of the data intake and query system 108. For example,with reference to FIG. 2, a user may install a software application onserver computers owned by the user and configure each server to operateas one or more components of the intake system 210, indexing system 212,query system 214, common storage 216, data store catalog 220, or queryacceleration data store 222, etc. This arrangement generally may bereferred to as an “on-premises” solution. That is, the system 108 isinstalled and operates on computing devices directly controlled by theuser of the system. Some users may prefer an on-premises solutionbecause it may provide a greater level of control over the configurationof certain aspects of the system (e.g., security, privacy, standards,controls, etc.). However, other users may instead prefer an arrangementin which the user is not directly responsible for providing and managingthe computing devices upon which various components of system 108operate.

In certain embodiments, one or more of the components of the data intakeand query system 108 can be implemented in a remote distributedcomputing system. In this context, a remote distributed computing systemor cloud-based service can refer to a service hosted by one morecomputing resources that are accessible to end users over a network, forexample, by using a web browser or other application on a client deviceto interface with the remote computing resources. For example, a serviceprovider may provide a data intake and query system 108 by managingcomputing resources configured to implement various aspects of thesystem (e.g., intake system 210, indexing system 212, query system 214,common storage 216, data store catalog 220, or query acceleration datastore 222, etc.) and by providing access to the system to end users viaa network. Typically, a user may pay a subscription or other fee to usesuch a service. Each subscribing user of the cloud-based service may beprovided with an account that enables the user to configure a customizedcloud-based system based on the user's preferences.

When implemented in a remote distributed computing system, theunderlying hardware (non-limiting examples: processors, hard drives,solid-state memory, RAM, etc.) on which the components of the dataintake and query system 108 execute can be shared by multiple customersor tenants as part of a shared computing resource environment. Inaddition, when implemented in a shared computing resource environment asa cloud-based service, various components of the system 108 can beimplemented using containerization or operating-system-levelvirtualization, or other virtualization technique. For example, one ormore components of the intake system 210, indexing system 212, or querysystem 214 can be implemented as separate software containers orcontainer instances. Each container instance can have certain resources(e.g., memory, processor, etc.) of an underlying host computing system(e.g., server, microprocessor, etc.) assigned to it, but may share thesame operating system and may use the operating system's system callinterface. Each container may provide an isolated execution environmenton the host system, such as by providing a memory space of the hostsystem that is logically isolated from memory space of other containers.Further, each container may run the same or different computerapplications concurrently or separately, and may interact with eachother. Although reference is made herein to containerization andcontainer instances, it will be understood that other virtualizationtechniques can be used. For example, the components can be implementedusing virtual machines using full virtualization or paravirtualization,etc. Thus, where reference is made to “containerized” components, itshould be understood that such components may additionally oralternatively be implemented in other isolated execution environments,such as a virtual machine environment.

Implementing the data intake and query system 108 in a remotedistributed system, shared computing resource environment, or as acloud-based service can provide a number of benefits. In some cases,implementing the data intake and query system 108 in a remotedistributed system, shared computing resource environment, or as acloud-based service can make it easier to install, maintain, and updatethe components of the data intake and query system 108. For example,rather than accessing designated hardware at a particular location toinstall or provide a component of the data intake and query system 108,a component can be remotely instantiated or updated as desired.Similarly, implementing the data intake and query system 108 in a remotedistributed system, shared computing resource environment, or as acloud-based service can make it easier to meet dynamic demand. Forexample, if the data intake and query system 108 experiences significantload at indexing or search, additional compute resources can be deployedto process the additional data or queries. In an “on-premises”environment, this type of flexibility and scalability may not bepossible or feasible.

In addition, by implementing the data intake and query system 108 in aremote distributed system, shared computing resource environment, or asa cloud-based service can improve compute resource utilization. Forexample, in an on-premises environment if the designated computeresources are not being used by, they may sit idle and unused. In ashared computing resource environment, if the compute resources for aparticular component are not being used, they can be re-allocated toother tasks within the data intake and query system 108 and/or to othersystems unrelated to the data intake and query system 108.

As mentioned, in an on-premises environment, data from one instance of adata intake and query system 108 is logically and physically separatedfrom the data of another instance of a data intake and query system byvirtue of each instance having its own designated hardware. As such,data from different customers of the data intake and query system islogically and physically separated from each other.

In a shared computing resource environment, one instance of a dataintake and query system can be configured to process the data from onecustomer or tenant or from multiple customers or tenants. Even in caseswhere a separate instance of a data intake and query system is used foreach customer, the underlying hardware on which the instances of thedata intake and query system 108 are instantiated may still process datafrom different tenants. Accordingly, in a shared computing resourceenvironment, the data from different tenants may not be physicallyseparated on distinct hardware devices. For example, data from onetenant may reside on the same hard drive as data from another tenant orbe processed by the same processor. In such cases, the data intake andquery system 108 can maintain logical separation between tenant data.For example, the data intake and query system can include separatedirectories for different tenants and apply different permissions andaccess controls to access the different directories or to process thedata, etc.

In certain cases, the tenant data from different tenants is mutuallyexclusive and/or independent from each other. For example, in certaincases, Tenant A and Tenant B do not share the same data, similar to theway in which data from a local hard drive of Customer A is mutuallyexclusive and independent of the data (and not considered part) of alocal hard drive of Customer B. While Tenant A and Tenant B may havematching or identical data, each tenant would have a separate copy ofthe data. For example, with reference again to the local hard drive ofCustomer A and Customer B example, each hard drive could include thesame file. However, each instance of the file would be considered partof the separate hard drive and would be independent of the other file.Thus, one copy of the file would be part of Customer's A hard drive anda separate copy of the file would be part of Customer B's hard drive. Ina similar manner, to the extent Tenant A has a file that is identical toa file of Tenant B, each tenant would have a distinct and independentcopy of the file stored in different locations on a data store or ondifferent data stores.

Further, in certain cases, the data intake and query system 108 canmaintain the mutual exclusivity and/or independence between tenant dataeven as the tenant data is being processed, stored, and searched by thesame underlying hardware. In certain cases, to maintain the mutualexclusivity and/or independence between the data of different tenants,the data intake and query system can use tenant identifiers to uniquelyidentify data associated with different tenants.

In a shared computing resource environment, some components of the dataintake and query system can be instantiated and designated forindividual tenants and other components can be shared by multipletenants. In certain embodiments, a separate intake system 210, indexingsystem 212, and query system 214 can be instantiated for each tenant,whereas the common storage 216, data store catalog 220, metadata catalog221, and/or acceleration data store 222, can be shared by multipletenants. In some such embodiments, the common storage 216, data storecatalog 220, metadata catalog 221, and/or acceleration data store 222,can maintain separate directories for the different tenants to ensuretheir mutual exclusivity and/or independence from each other. Similarly,in some such embodiments, the data intake and query system 108 can usedifferent host computing systems or different isolated executionenvironments to process the data from the different tenants as part ofthe intake system 210, indexing system 212, and/or query system 214.

In some embodiments, individual components of the intake system 210,indexing system 212, and/or query system 214 may be instantiated foreach tenant or shared by multiple tenants. For example, individualforwarders 302 and an output ingestion buffer 310 may be instantiatedand designated for individual tenants, while the data retrievalsubsystem 304, intake ingestion buffer 306, and/or streaming dataprocessor 308, may be shared by multiple tenants. In certainembodiments, the data retrieval subsystem 304, intake ingestion buffer306, streaming data processor 308, and output ingestion buffer 310 maybe shared by multiple tenants.

In certain embodiments, an indexing system can be instantiated anddesignated for a particular tenant or shared by multiple tenants. As anon-limiting example, in certain cases, the embodiment of the indexingsystem 212 shown in FIG. 4A may be allocated for each tenant of the dataintake and query system 108. As another non-limiting example, in somecases, the components of the embodiment of the indexing system 212 shownin FIG. 4B can be shared by multiple tenants.

In some embodiments where a separate indexing system 212 is instantiatedand designated for each tenant, different resources can be reserved fordifferent tenants. For example, Tenant A can be consistently allocated aminimum of four indexing nodes and Tenant B can be consistentlyallocated a minimum of two indexing nodes. In some such embodiments, thefour indexing nodes can be reserved for Tenant A and the two indexingnodes can be reserved for Tenant B, even if Tenant A and Tenant B arenot using the reserved indexing nodes.

In embodiments where an indexing system 212 is shared by multipletenants, different resources can be dynamically assigned to differenttenants. For example, if Tenant A has greater indexing demands,additional indexing nodes can be instantiated or assigned to Tenant A'sdata. However, as the demand decreases, the indexing nodes can bereassigned to a different tenant, or terminated. Further, in someembodiments, a component of the indexing system 212, such as an ingestmanager 406, partition manager 408, and/or indexing node 404, canconcurrently process data from the different tenants.

In some embodiments, one instance of query system 214 may be shared bymultiple tenants. In some such cases, the same search head 504 can beused to process/execute queries for different tenants and/or the samesearch nodes 506 can be used to execute query for different tenants.Further, in some such cases, different tenants can be allocateddifferent amounts of compute resources. For example, Tenant A may beassigned more search heads 504 or search nodes 506 based on demand orbased on a service level arrangement than another tenant. However, oncea search is completed the search head and/or nodes assigned to Tenant Amay be assigned to Tenant B, deactivated, or their resource may bere-allocated to other components of the data intake and query system,etc.

In some cases, by sharing more components with different tenants, thefunctioning of the data intake and query system 108 can be improved. Forexample, by sharing components across tenants, the data intake and querysystem can improve resource utilization thereby reducing the amount ofresources allocated as a whole. For example, if four indexing nodes, twosearch heads, and four search nodes are reserved for each tenant thenthose compute resources are unavailable for use by other processes ortenants, even if they go unused. In contrast, by sharing the indexingnodes, search heads, and search nodes with different tenants andinstantiating additional compute resources, the data intake and querysystem can use fewer resources overall while providing improvedprocessing time for the tenants that are using the compute resources.For example, if tenant A is not using any search nodes 506 and tenant Bhas many searches running, the data intake and query system 214 can usesearch nodes that would have been reserved for tenant A to servicetenant B. In this way, the data intake and query system can decrease thenumber of compute resources used/reserved, while improving the searchtime for tenant B and improving compute resource utilization.

3.0. Data Intake and Query System Architecture

FIG. 2 is a block diagram of an embodiment of a data processingenvironment 200. In the illustrated embodiment, the environment 200includes data sources 202, client devices 204 a, 204 b . . . 204 n(generically referred to as client device(s) 204), and an applicationenvironment 205, in communication with a data intake and query system108 via networks 206, 208, respectively. The networks 206, 208 may bethe same network, may correspond to the network 104, or may be differentnetworks. Further, the networks 206, 208 may be implemented as one ormore LANs, WANs, cellular networks, intranetworks, and/or internetworksusing any of wired, wireless, terrestrial microwave, satellite links,etc., and may include the Internet.

Each data source 202 broadly represents a distinct source of data thatcan be consumed by the data intake and query system 108. Examples ofdata sources 202 include, without limitation, data files, directories offiles, data sent over a network, event logs, registries, streaming dataservices (examples of which can include, by way of non-limiting example,Amazon's Simple Queue Service (“SQS”) or Kinesis™ services, devicesexecuting Apache Kafka™ software, or devices implementing the MessageQueue Telemetry Transport (MQTT) protocol, Microsoft Azure EventHub,Google Cloud PubSub, devices implementing the Java Message Service (JMS)protocol, devices implementing the Advanced Message Queuing Protocol(AMQP)), performance metrics, cloud-based services (e.g., AWS, MicrosoftAzure, Google Cloud, etc.), operating-system-level virtualizationenvironments (e.g., Docker), container orchestration systems (e.g.,Kubernetes), virtual machines using full virtualization orparavirtualization, or other virtualization technique or isolatedexecution environments.

As illustrated in FIG. 2, in some embodiments, the data sources 202 cancommunicate with the data to the intake system 210 via the network 206without passing through the gateway 215. As a non-limiting example, ifthe intake system 210 receives the data from a data source 202 via aforwarder 302 (described in greater detail below), the intake system 210may receive the data via the network 206 without going through thegateway 215. In certain embodiments, the data sources 202 cancommunicate the data to the intake system 210 via the network 206 usingthe gateway 215. As another non-limiting example, if the intake system210 receives the data from a data source 202 via a HTTP intake point 322(described in greater detail below), it may receive the data via thegateway 215. Accordingly, it will be understood that a variety ofmethods can be used to receive data from the data sources 202 via thenetwork 206 or via the network 206 and the gateway 215.

The client devices 204 can be implemented using one or more computingdevices in communication with the data intake and query system 108, andrepresent some of the different ways in which computing devices cansubmit queries to the data intake and query system 108. For example, theclient device 204 a is illustrated as communicating over an Internet(Web) protocol with the data intake and query system 108, the clientdevice 204 b is illustrated as communicating with the data intake andquery system 108 via a command line interface, and the client device 204n is illustrated as communicating with the data intake and query system108 via a software developer kit (SDK). However, it will be understoodthat the client devices 204 can communicate with and submit queries tothe data intake and query system 108 in a variety of ways. For example,the client devices 204 can use one or more executable applications orprograms from the application environment 205 to interface with the dataintake and query system 108. The application environment 205 can includetools, software modules (e.g., computer executable instructions toperform a particular function), etc., to enable application developersto create computer executable applications to interface with the dataintake and query system 108. For example, application developers canidentify particular data that is of particular relevance to them. Theapplication developers can use the application environment 205 to builda particular application to interface with the data intake and querysystem 108 to obtain the relevant data that they seek, process therelevant data, and display it in a manner that is consumable or easilyunderstood by a user. The applications developed using the applicationenvironment 205 can include their own backend services, middlewarelogic, front-end user interface, etc., and can provide facilities foringesting use case specific data and interacting with that data.

In certain embodiments, the developed applications can be executed by acomputing device or in an isolated execution environment of an isolatedexecution environment system, such as Kubernetes, AWS, Microsoft Azure,Google Cloud, etc. In addition, some embodiments, the applicationenvironments 205 can provide one or more isolated execution environmentsin which to execute the developed applications. In some cases, theapplications are executed in an isolated execution environment or aprocessing device unrelated to the application environment 205.

As a non-limiting example, an application developed using theapplication environment 205 can include a custom web-user interface thatmay or may not leverage one or more UI components provided by theapplication environment 205. The application could include middle-warebusiness logic, on a middle-ware platform of the developer's choice.Furthermore, as mentioned the applications implemented using theapplication environment 205 can be instantiated and execute in adifferent isolated execution environment or different isolated executionenvironment system than the data intake and query system 108. As anon-limiting example, in embodiments where the data intake and querysystem 108 is implemented using a Kubernetes cluster, the applicationsdeveloped using the application environment 205 can execute in adifferent Kubernetes cluster (or other isolated execution environmentsystem) and interact with the data intake and query system 108 via thegateway 215.

The data intake and query system 108 can process and store data receiveddata from the data sources 202 and execute queries on the data inresponse to requests received from the client devices 204. In theillustrated embodiment, the data intake and query system 108 includes agateway 209, an intake system 210, an indexing system 212, a querysystem 214, common storage 216 including one or more data stores 218, adata store catalog 220, a metadata catalog 221, and a query accelerationdata store 222. Although certain communication pathways are illustratedin FIG. 2, it will be understood that, in certain embodiments, anycomponent of the data intake and query system 108 can interact with anyother component of the data intake and query system 108. For example,the gateway 215 can interact with one or more components of the indexingsystem 212 and/or one or more components of the intake system 210 cancommunicate with the metadata catalog 221. Thus, data and/or commandscan be communicated in a variety of ways within the data intake andquery system 108.

As will be described in greater detail herein, the gateway 215 canprovide an interface between one or more components of the data intakeand query system 108 and other systems or computing devices, such as,but not limited to, client devices 204, the application environment 205,one or more data sources 202, and/or other systems 262. In someembodiments, the gateway 215 can be implemented using an applicationprogramming interface (API). In certain embodiments, the gateway 215 canbe implemented using a representational state transfer API (REST API).

As mentioned, the data intake and query system 108 can receive data fromdifferent sources 202. In some cases, the data sources 202 can beassociated with different tenants or customers. Further, each tenant maybe associated with one or more indexes, hosts, sources, sourcetypes, orusers. For example, company ABC, Inc. can correspond to one tenant andcompany XYZ, Inc. can correspond to a different tenant. While the twocompanies may be unrelated, each company may have a main index and testindex (also referred to herein as a main partition or test partition)associated with it, as well as one or more data sources or systems(e.g., billing system, CRM system, etc.). The data intake and querysystem 108 can concurrently receive and process the data from thevarious systems and sources of ABC, Inc. and XYZ, Inc.

In certain cases, although the data from different tenants can beprocessed together or concurrently, the data intake and query system 108can take steps to avoid combining or co-mingling data from the differenttenants. For example, the data intake and query system 108 can assign atenant identifier for each tenant and maintain a separation between thedata using the tenant identifier. In some cases, the tenant identifiercan be assigned to the data at the data sources 202, or can be assignedto the data by the data intake and query system 108 at ingest.

As will be described in greater detail herein, at least with referenceto FIGS. 3A and 3B, the intake system 210 can receive data from the datasources 202, perform one or more preliminary processing operations onthe data, and communicate the data to the indexing system 212, querysystem 214, or to other systems 262 (which may include, for example,data processing systems, telemetry systems, real-time analytics systems,data stores, databases, etc., any of which may be operated by anoperator of the data intake and query system 108 or a third partY).

The intake system 210 can receive data from the data sources 202 in avariety of formats or structures. In some embodiments, the received datacorresponds to raw machine data, structured or unstructured data,correlation data, data files, directories of files, data sent over anetwork, event logs, registries, messages published to streaming datasources, performance metrics, sensor data, image and video data, etc.

The intake system 210 can process the data based on the form in which itis received. In some cases, the intake system 210 can utilize one ormore rules to process data and to make the data available to downstreamsystems (e.g., the indexing system 212, query system 214, etc.).Illustratively, the intake system 210 can enrich the received data. Forexample, the intake system may add one or more fields to the datareceived from the data sources 202, such as fields denoting the host,source, sourcetype, index, or tenant associated with the incoming data.In certain embodiments, the intake system 210 can perform additionalprocessing on the incoming data, such as transforming structured datainto unstructured data (or vice versa), identifying timestampsassociated with the data, removing extraneous data, parsing data,indexing data, separating data, categorizing data, routing data based oncriteria relating to the data being routed, and/or performing other datatransformations, etc.

In some cases, the data processed by the intake system can becommunicated or made available to the indexing system 212, the querysystem 214, and/or to other systems 262. In some embodiments, the intakesystem 210 communicates or makes available streams of data using one ormore shards or partitions. For example, the indexing system 212 may reador receive data from one shard and another system may receive data fromanother shard. As another example, multiple systems may receive datafrom the same shard or partition.

As used herein, a partition can refer to a logical division of data. Insome cases, the logical division of data may refer to a portion of adata stream, such as a shard from the intake system 210. In certaincases, the logical division of data can refer to an index or otherportion of data stored in the data store 412 or common storage 216, suchas different directories or file structures used to store data orbuckets. Accordingly, it will be understood that the logical division ofdata referenced by the term partition will be understood based on thecontext of its use.

As will be described in greater detail herein, at least with referenceto FIGS. 4A and 4B, the indexing system 212 can process the data andstore it, for example, in common storage 216. As part of processing thedata, the indexing system can identify timestamps associated with thedata, organize the data into buckets or time series buckets, converteditable buckets to non-editable buckets, store copies of the buckets incommon storage 216, merge buckets, generate indexes of the data, etc. Inaddition, the indexing system 212 can update the data store catalog 220with information related to the buckets (pre-merged or merged) or datathat is stored in common storage 216, and can communicate with theintake system 210 about the status of the data storage.

As will be described in greater detail herein, at least with referenceto FIG. 5, the query system 214 can receive queries that identify a setof data to be processed and a manner of processing the set of data fromone or more client devices 204, process the queries to identify the setof data, and execute the query on the set of data. In some cases, aspart of executing the query, the query system 214 can use the data storecatalog 220 to identify the set of data to be processed or its locationin common storage 216 and/or can retrieve data from common storage 216or the query acceleration data store 222. In addition, in someembodiments, the query system 214 can store some or all of the queryresults in the query acceleration data store 222.

As mentioned and as will be described in greater detail below, thecommon storage 216 can be made up of one or more data stores 218 storingdata that has been processed by the indexing system 212. The commonstorage 216 can be configured to provide high availability, highlyresilient, low loss data storage. In some cases, to provide the highavailability, highly resilient, low loss data storage, the commonstorage 216 can store multiple copies of the data in the same anddifferent geographic locations and across different types of data stores(e.g., solid state, hard drive, tape, etc.). Further, as data isreceived at the common storage 216 it can be automatically replicatedmultiple times according to a replication factor to different datastores across the same and/or different geographic locations. In someembodiments, the common storage 216 can correspond to cloud storage,such as Amazon Simple Storage Service (S3) or Elastic Block Storage(EBS), Google Cloud Storage, Microsoft Azure Storage, etc.

In some embodiments, indexing system 212 can read to and write from thecommon storage 216. For example, the indexing system 212 can copybuckets of data from its local or shared data stores to the commonstorage 216. In certain embodiments, the query system 214 can read from,but cannot write to, the common storage 216. For example, the querysystem 214 can read the buckets of data stored in common storage 216 bythe indexing system 212, but may not be able to copy buckets or otherdata to the common storage 216. In some embodiments, the intake system210 does not have access to the common storage 216. However, in someembodiments, one or more components of the intake system 210 can writedata to the common storage 216 that can be read by the indexing system212.

As described herein, in some embodiments, data in the data intake andquery system 108 (e.g., in the data stores of the indexers of theindexing system 212, common storage 216, or search nodes of the querysystem 214) can be stored in one or more time series buckets. Eachbucket can include raw machine data associated with a time stamp andadditional information about the data or bucket, such as, but notlimited to, one or more filters, indexes (e.g., TSIDX, inverted indexes,keyword indexes, etc.), bucket summaries, etc. In some embodiments, thebucket data and information about the bucket data is stored in one ormore files. For example, the raw machine data, filters, indexes, bucketsummaries, etc. can be stored in respective files in or associated witha bucket. In certain cases, the group of files can be associatedtogether to form the bucket.

The data store catalog 220 can store information about the data storedin common storage 216, such as, but not limited to an identifier for aset of data or buckets, a location of the set of data, tenants orindexes associated with the set of data, timing information about thedata, etc. For example, in embodiments where the data in common storage216 is stored as buckets, the data store catalog 220 can include abucket identifier for the buckets in common storage 216, a location ofor path to the bucket in common storage 216, a time range of the data inthe bucket (e.g., range of time between the first-in-time event of thebucket and the last-in-time event of the bucket), a tenant identifieridentifying a customer or computing device associated with the bucket,and/or an index (also referred to herein as a partition) associated withthe bucket, etc. In certain embodiments, the data intake and querysystem 108 includes multiple data store catalogs 220. For example, insome embodiments, the data intake and query system 108 can include adata store catalog 220 for each tenant (or group of tenants), eachpartition of each tenant (or group of indexes), etc. In some cases, thedata intake and query system 108 can include a single data store catalog220 that includes information about buckets associated with multiple orall of the tenants associated with the data intake and query system 108.

The indexing system 212 can update the data store catalog 220 as theindexing system 212 stores data in common storage 216. Furthermore, theindexing system 212 or other computing device associated with the datastore catalog 220 can update the data store catalog 220 as theinformation in the common storage 216 changes (e.g., as buckets incommon storage 216 are merged, deleted, etc.). In addition, as describedherein, the query system 214 can use the data store catalog 220 toidentify data to be searched or data that satisfies at least a portionof a query. In some embodiments, the query system 214 makes requests toand receives data from the data store catalog 220 using an applicationprogramming interface (“API”).

As will be described in greater detail herein, at least with referenceto FIGS. 6 and 22-27, the metadata catalog 221 can store informationabout datasets used or supported by the data intake and query system 108and/or one or more rules that indicate which data in a dataset toprocess and how to process the data from the dataset. The informationabout the datasets can include configuration information, such as, butnot limited to the type of the dataset, access and authorizationinformation for the dataset, location information for the dataset,physical and logical names or other identifiers for the dataset, etc.The rules can indicate how different data of a dataset is to beprocessed and/or how to extract fields or field values from differentdata of a dataset.

The metadata catalog 221 can also include one or more datasetassociation records. The dataset association records can indicate how torefer to a particular dataset (e.g., a name or other identifier for thedataset) and/or identify associations or relationships between theparticular dataset and one or more rules or other datasets. In someembodiments, a dataset association record can be similar to a namespacein that it can indicate a scope of one or more datasets and the mannerin which to reference the one or more datasets. As a non-limitingexample, one dataset association record can identify four datasets: a“main” index dataset, a “test” index dataset, a “username” collectiondataset, and a “username” lookup dataset. The dataset association recordcan also identify one or more rules for one or more of the datasets. Forexample, one rule can indicate that for data with the sourcetype “foo”from the “main” index dataset (or all datasets of the datasetassociation record), multiple actions are to take place, such as,extracting a field value for a “UID” field, and using the “username”lookup dataset to identify a username associated with the extracted“UID” field value. The actions of the rule can provide specific guidanceas to how to extract the field value for the “UID” field from thesourcetype “foo” data in the “main” index dataset and how to perform thelookup of the username.

As described herein, the query system 214 can use the metadata catalog221 to, among other things, interpret dataset identifiers in a query,verify/authenticate a user's permissions and/or authorizations fordifferent datasets, identify additional processing as part of the query,identify one or more datasets from which to retrieve data as part of thequery (also referred to herein as source datasets), determine how toextract data from datasets, identifyconfigurations/definitions/dependencies to be used by search nodes toexecute the query, etc.

In certain embodiments, the query system 214 can use the metadatacatalog 221 to provide a stateless search service. For example, thequery system 214 can use the metadata catalog 221 to dynamicallydetermine the dataset configurations and rule configurations to be usedto execute a query (also referred to herein as the query configurationparameters) and communicate the query configuration parameters to one ormore search heads 504. If the query system 214 determines that anassigned search head 504 becomes unavailable, the query system 214 cancommunicate the dynamically determined query configuration parameters(and query to be executed) to another search head 504 without data lossand/or with minimal or reduced time loss.

In some embodiments, the metadata catalog 221 can be implemented using adatabase system, such as, but not limited to, a relational databasesystem (non-limiting commercial examples: DynamoDB, Aurora DB, etc.). Incertain embodiments, the database system can include entries for thedifferent datasets, rules, and/or dataset association records. Moreover,as described herein, the metadata catalog 221 can be modified over timeas information is learned about the datasets associated with or managedby the data intake and query system 108. For example, the entries in thedatabase system can include manual or system annotations, as describedherein.

The query acceleration data store 222 can store the results or partialresults of queries, or otherwise be used to accelerate queries. Forexample, if a user submits a query that has no end date, the querysystem 214 can store an initial set of results in the query accelerationdata store 222. As additional query results are determined based onadditional data, the additional results can be combined with the initialset of results, and so on. In this way, the query system 214 can avoidre-searching all of the data that may be responsive to the query andinstead search the data that has not already been searched.

3.1. Gateway and Authentication Flow

As described herein, the gateway 215 can provide an interface betweenone or more components of the data intake and query system 108(non-limiting examples: one or more components of the intake system 210,one or more components of the indexing system 212, one or morecomponents of the query system 214, common storage 216, the data storecatalog 220, the metadata catalog 221 and/or the acceleration data store222), and other systems or computing devices, such as, but not limitedto, client devices 204, the application environment 205, one or moredata sources 202, and/or other systems 262 (not illustrated). In somecases, one or more components of the data intake and query system 108can include their own API. In such embodiments, the gateway 215 cancommunicate with the API of a component of the data intake and querysystem 108. Accordingly, the gateway 215 can translate requests receivedfrom an external device into a command understood by the API of thespecific component of the data intake and query system 108. In this way,the gateway 215 can provide an interface between external devices andthe API of the devices of the data intake and query system 108. In someimplementations, components of the query system or other components maynot be reachable through the gateway, or may be separatelyaccess-controlled. For example, in some implementations, the resourcecatalog 270 and the resource monitor 272 may be inaccessible fromoutside the gateway, and may be accessed by internal components.

In some embodiments, the gateway 215 can be implemented using an API,such as the REST API. In some such embodiments, the client devices 204can communicate via one or more commands, such as GET, PUT, etc.However, it will be understood that the gateway 215 can be implementedin a variety of ways to enable the external devices and/or systems tointerface with one or more components of the data intake and querysystem 108.

In certain embodiments, a client device 204 can provide controlparameters to the data intake and query system 108 via the gateway 215.As a non-limiting example, using the gateway 215, a client device 204can provide instructions to the metadata catalog 221, the intake system210, indexing system 212, and/or the query system 214. For example,using the gateway 215, a client device 204 can instruct the metadatacatalog 221 to add/modify/delete a dataset association record, dataset,rule, configuration, and/or action, etc. As another example, using thegateway 215, a client device 204 can provide a query to the query system214 and receive results. As yet another example, using the gateway 215,a client device 204 can provide processing instructions to the intakesystem 210. As yet another example, using the gateway 215, one or moredata sources 202 can provide data to the intake system 210. In someembodiments, one or more components of the intake system 210 can receivedata from a data source 202 via the gateway 215. For example, in someembodiments, data received by the HTTP intake point 322 and/or customintake points 332 (described in greater detail below) of the intakesystem 210 can be received via the gateway 215.

As mentioned, upon receipt of a request or command from an externaldevice, the gateway 215 can determine the component of the data intakeand query system 108 (or service) to handle the request. In someembodiments, the request or command can include an identifier for thecomponent associated with the request or command. In certainembodiments, the gateway 215 can determine the component to handle therequest based on the type of request or services requested by thecommand. For example, if the request or command relates to (or includes)a query, the gateway 215 can determine that the command is to be sent toa component of the query system 214. As another example, if the requestor command includes data, such as raw machine data, metrics, ormetadata, the gateway 215 can determine that the request or command isto be sent to a component of the intake system 210 (non-limitingexamples: HTTP intake point 322 or other push-based publisher 320,custom intake point 332A or other pull-based publisher 330, etc.) orindexing system 212 (non-limiting example: indexing node 404, etc.). Asyet another example, if the gateway 215 determines that the request orcommand relates to the modification of a dataset or rule, it cancommunicate the command or request to the metadata catalog 221.

Furthermore, in some cases, the gateway 215 can translate the request orcommand received from the external device into a command that can beinterpreted by the component of the data intake and query system 108.For example, the request or command received by the gateway 215 may notbe interpretable or understood by the component of the data intake andquery system 108 that is to process the command or request. Moreover, asmentioned, in certain embodiments, one or more components of the dataintake and query system 108 can use an API to interact with othercomponents of the data intake and query system 108. Accordingly, thegateway 215 can generate a command for the component of the data intakeand query system 108 that is to process the command or request based onthe received command or request and the information about the API of thecomponent of the data intake and query system 108 (or the componentitself).

In some cases, the gateway 215 can expose a subset of components and/ora limited number of features of the components of the data intake andquery system 108 to the external devices. For example, for the querysystem 214, the gateway 215, may expose the ability to submit queriesbut may not expose the ability to configure certain components of thequery system 214, such as the resource catalog 510, resource monitor508, and/or cache manager 516 (described in greater detail below).However, it will be understood that the gateway 215 can be configured toexpose fewer or more components and/or fewer or more functions for thedifferent components as desired. By limiting the components or commandsfor the components of the data intake and query system, the gateway 215can provide improved security for the data intake and query system 108.

In addition to limiting the components or functions made available toexternal systems, the gateway 215 can provide authentication and/orauthorization functionality. For example, with each request or commandreceived by a client device and/or data source 202, the gateway 215 canauthenticate the computing device from which the requester command wasreceived and/or determine whether the requester has sufficientpermissions or authorizations to make the request. In this way, thegateway 215 can provide additional security for the data intake andquery system 108.

FIG. 2B is a flow diagram illustrative of an embodiment of a routine 250implemented by the data intake and query system 108 to enable a useraccess to one or more components of the data intake and query system108. Although described as being implemented by the system 108, it willbe understood that the elements outlined for routine 250 can beimplemented by one or more computing devices/components that areassociated with the data intake and query system 108, such as, but notlimited to, a computing device associated with the gateway 215, anauthentication computing device and/or data store, a component of theintake system 210, indexing system 212, and/or query system 214, or by asystem in communication with the data intake and query system 108, suchas an authentication system, etc. Thus, the following illustrativeembodiment should not be construed as limiting.

At block 252, the system 108 receives a request to access the dataintake and query system 108. In some cases, the system 108 receives therequest via an API. For example, a user can request access by entering acommand that issues an API call to the system 108. In some cases, theAPI call or request can include the user's login information, such as ausername and password, biometric data, or other credential, etc. Incertain embodiments, the user's computer can make the API call based ona user accessing a particular URL or IP address, or entering logincredentials on a webpage or login page.

As described herein, the system 108 can process machine data receivedfrom data sources to generate events. The machine data, or raw machinedata, can reflect activity in an IT environment, etc. In some cases, theevents can include raw machine data associated with a timestamp and/orcan be stored in one or more time series, field-searchable buckets ordata stores.

At block 254, the system 108 authenticates the user. In some cases, thesystem 108 can authenticate the user by comparing the receivedcredentials with credentials of known users of the system 108. Incertain embodiments, the system 108 can authenticate the user byproviding the credentials to an external authentication system thatauthenticates the user, etc. Based on a match of the receivedcredentials with credentials of a known user, the system 108 canauthenticate the user. In some cases, as part of authenticating the userthe system 108 can determine the permissions of the users, such as, thedatasets, or components of the system 108 that the user can access. Insome cases, users can have different permissions to different componentsof the system. For example, one user may have access to the intakesystem 210, indexing system 212, and query system 214, and another usermay only have access to the query system 214. As another example, oneuser may be identified as an administrator and have permissions toaccess and/or modify configuration files, etc., and another user mayonly have read-only permissions in order to execute queries and receiveresults of the queries.

At block 256, the system 108 receives a request for a component of thedata intake and query system 108. In some cases, after logging into andobtaining access to the system 108, the user can use a computing deviceto submit an API call that include a request for a component of the dataintake and query system to perform an action. For example, the requestmay include a command to execute a query, modify/add/delete data in themetadata catalog 221 (e.g., dataset, rule, dataset association record,dataset configuration record, rule configuration record, data source,tenant information, user information, etc.), modify user permissions,process data, or modify a processing flow of data, etc. In someembodiments, the request for access and the request for the componentcan be part of the same API call or same request. For example, a requestmay include the login credentials of a user and a command for thecomponent, etc.

At block 258, the system 108 communicates the request to the component.In some cases, based on the authentication of the user, the system 108communicates the request for the component to the requested component.In certain embodiments, the system 108 can modify the received request.For example, the component to receive the request may have its own APIthat uses different syntax or commands than the API of the system 108.In some such cases, the system 108 can modify the request for thecomponent so that the component can properly understand the request andexecute the action associated with the request. Furthermore, thecomponent may require additional information that is not available tothe user. In some such cases, the system 108 can include the additionalinformation to the component.

Fewer, more, or different blocks can be used as part of the routine 250.In some cases, one or more blocks can be omitted. In some embodiments,the component can perform the action associated with the request (e.g.,execute query, modify metadata catalog 221, etc.) and return results. Incertain embodiments, the results can include query results or anacknowledgement that the action has been performed. In some embodiments,the component can authenticate the user before performing the action. Insome such embodiments, the component can authenticate the user in amanner similar to that done by the system 108.

In certain embodiments, a request may involve multiple components of thedata intake and query system 108. In some cases, the components canperform the action concurrently or sequentially. For example someactions may require that different steps be performed sequentially andothers may allow for steps to be performed concurrently. In either case,the different components of the system can perform relevant actionsbased on the authentication by the system 108 and/or an authenticationby the individual components, etc. In some embodiments, the blocks ofroutine 250 can be combined with any one or any combination of blocksdescribed herein with reference to at least FIGS. 10A-10D, 12A-12G,15A-15G, 16A, and 17A. Furthermore, it will be understood that thevarious blocks described herein with reference to FIG. 2B can beimplemented in a variety of orders, or can be performed concurrently.

3.2. Intake System

As detailed below, data may be ingested at the data intake and querysystem 108 through an intake system 210 configured to conductpreliminary processing on the data, and make the data available todownstream systems or components, such as the indexing system 212, querysystem 214, third party systems, etc.

One example configuration of an intake system 210 is shown in FIG. 3A.As shown in FIG. 3A, the intake system 210 includes a forwarder 302, adata retrieval subsystem 304, an intake ingestion buffer 306, astreaming data processor 308, and an output ingestion buffer 310. Asdescribed in detail below, the components of the intake system 210 maybe configured to process data according to a streaming data model, suchthat data ingested into the data intake and query system 108 isprocessed rapidly (e.g., within seconds or minutes of initial receptionat the intake system 210) and made available to downstream systems orcomponents. The initial processing of the intake system 210 may includesearch or analysis of the data ingested into the intake system 210. Forexample, the initial processing can transform data ingested into theintake system 210 sufficiently, for example, for the data to be searchedby a query system 214, thus enabling “real-time” searching for data onthe data intake and query system 108 (e.g., without requiring indexingof the data). Various additional and alternative uses for data processedby the intake system 210 are described below.

Although shown as separate components, the forwarder 302, data retrievalsubsystem 304, intake ingestion buffer 306, streaming data processors308, and output ingestion buffer 310, in various embodiments, may resideon the same machine or be distributed across multiple machines in anycombination. In one embodiment, any or all of the components of theintake system can be implemented using one or more computing devices asdistinct computing devices or as one or more container instances orvirtual machines across one or more computing devices. It will beappreciated by those skilled in the art that the intake system 210 mayhave more of fewer components than are illustrated in FIGS. 3A and 3B.In addition, the intake system 210 could include various web servicesand/or peer-to-peer network configurations or inter containercommunication network provided by an associated container instantiationor orchestration platform. Thus, the intake system 210 of FIGS. 3A and3B should be taken as illustrative. For example, in some embodiments,components of the intake system 210, such as the ingestion buffers 306and 310 and/or the streaming data processors 308, may be executed by onemore virtual machines implemented in a hosted computing environment. Ahosted computing environment may include one or more rapidly provisionedand released computing resources, which computing resources may includecomputing, networking and/or storage devices. A hosted computingenvironment may also be referred to as a cloud computing environment.Accordingly, the hosted computing environment can include anyproprietary or open source extensible computing technology, such asApache Flink or Apache Spark, to enable fast or on-demand horizontalcompute capacity scaling of the streaming data processor 308.

In some embodiments, some or all of the elements of the intake system210 (e.g., forwarder 302, data retrieval subsystem 304, intake ingestionbuffer 306, streaming data processors 308, and output ingestion buffer310, etc.) may reside on one or more computing devices, such as servers,which may be communicatively coupled with each other and with the datasources 202, query system 214, indexing system 212, or other components.In other embodiments, some or all of the elements of the intake system210 may be implemented as worker nodes as disclosed in U.S. patentapplication Ser. Nos. 15/665,159, 15/665,148, 15/665,187, 15/665,248,15/665,197, 15/665,279, 15/665,302, and 15/665,339, each of which isincorporated by reference herein in its entirety (hereinafter referredto as “the Incorporated Applications”).

As noted above, the intake system 210 can function to conductpreliminary processing of data ingested at the data intake and querysystem 108. As such, the intake system 210 illustratively includes aforwarder 302 that obtains data from a data source 202 and transmits thedata to a data retrieval subsystem 304. The data retrieval subsystem 304may be configured to convert or otherwise format data provided by theforwarder 302 into an appropriate format for inclusion at the intakeingestion buffer and transmit the message to the intake ingestion buffer306 for processing. Thereafter, a streaming data processor 308 mayobtain data from the intake ingestion buffer 306, process the dataaccording to one or more rules, and republish the data to either theintake ingestion buffer 306 (e.g., for additional processing) or to theoutput ingestion buffer 310, such that the data is made available todownstream components or systems. In this manner, the intake system 210may repeatedly or iteratively process data according to any of a varietyof rules, such that the data is formatted for use on the data intake andquery system 108 or any other system. As discussed below, the intakesystem 210 may be configured to conduct such processing rapidly (e.g.,in “real-time” with little or no perceptible delay), while ensuringresiliency of the data.

3.2.1. Forwarder

The forwarder 302 can include or be executed on a computing deviceconfigured to obtain data from a data source 202 and transmit the datato the data retrieval subsystem 304. In some implementations, theforwarder 302 can be installed on a computing device associated with thedata source 202 or directly on the data source 202. While a singleforwarder 302 is illustratively shown in FIG. 3A, the intake system 210may include a number of different forwarders 302. Each forwarder 302 mayillustratively be associated with a different data source 202. Aforwarder 302 initially may receive the data as a raw data streamgenerated by the data source 202. For example, a forwarder 302 mayreceive a data stream from a log file generated by an applicationserver, from a stream of network data from a network device, or from anyother source of data. In some embodiments, a forwarder 302 receives theraw data and may segment the data stream into “blocks”, possibly of auniform data size, to facilitate subsequent processing steps. Theforwarder 302 may additionally or alternatively modify data received,prior to forwarding the data to the data retrieval subsystem 304.Illustratively, the forwarder 302 may “tag” metadata for each datablock, such as by specifying a source, source type, or host associatedwith the data, or by appending one or more timestamp or time ranges toeach data block.

In some embodiments, a forwarder 302 may comprise a service accessibleto data sources 202 via a network 206. For example, one type offorwarder 302 may be capable of consuming vast amounts of real-time datafrom a potentially large number of data sources 202. The forwarder 302may, for example, comprise a computing device which implements multipledata pipelines or “queues” to handle forwarding of network data to dataretrieval subsystems 304.

3.2.2. Data Retrieval Subsystem

The data retrieval subsystem 304 illustratively corresponds to acomputing device which obtains data (e.g., from the forwarder 302), andtransforms the data into a format suitable for publication on the intakeingestion buffer 306. Illustratively, where the forwarder 302 segmentsinput data into discrete blocks, the data retrieval subsystem 304 maygenerate a message for each block, and publish the message to the intakeingestion buffer 306. Generation of a message for each block mayinclude, for example, formatting the data of the message in accordancewith the requirements of a streaming data system implementing the intakeingestion buffer 306, the requirements of which may vary according tothe streaming data system. In one embodiment, the intake ingestionbuffer 306 formats messages according to the protocol buffers method ofserializing structured data. Thus, the intake ingestion buffer 306 maybe configured to convert data from an input format into a protocolbuffer format. Where a forwarder 302 does not segment input data intodiscrete blocks, the data retrieval subsystem 304 may itself segment thedata. Similarly, the data retrieval subsystem 304 may append metadata tothe input data, such as a source, source type, or host associated withthe data.

Generation of the message may include “tagging” the message with variousinformation, which may be included as metadata for the data provided bythe forwarder 302, and determining a “topic” for the message, underwhich the message should be published to the intake ingestion buffer306. In general, the “topic” of a message may reflect a categorizationof the message on a streaming data system. Illustratively, each topicmay be associated with a logically distinct queue of messages, such thata downstream device or system may “subscribe” to the topic in order tobe provided with messages published to the topic on the streaming datasystem.

In one embodiment, the data retrieval subsystem 304 may obtain a set oftopic rules (e.g., provided by a user of the data intake and querysystem 108 or based on automatic inspection or identification of thevarious upstream and downstream components of the data intake and querysystem 108) that determine a topic for a message as a function of thereceived data or metadata regarding the received data. For example, thetopic of a message may be determined as a function of the data source202 from which the data stems. After generation of a message based oninput data, the data retrieval subsystem can publish the message to theintake ingestion buffer 306 under the determined topic.

While the data retrieval subsystem 304 is depicted in FIG. 3A asobtaining data from the forwarder 302, the data retrieval subsystem 304may additionally or alternatively obtain data from other sources, suchas from the data source 202 and/or via the gateway 209. In someinstances, the data retrieval subsystem 304 may be implemented as aplurality of intake points, each functioning to obtain data from one ormore corresponding data sources (e.g., the forwarder 302, data sources202, or any other data source), generate messages corresponding to thedata, determine topics to which the messages should be published, and topublish the messages to one or more topics of the intake ingestionbuffer 306.

One illustrative set of intake points implementing the data retrievalsubsystem 304 is shown in FIG. 3B. Specifically, as shown in FIG. 3B,the data retrieval subsystem 304 of FIG. 3A may be implemented as a setof push-based publishers 320 or a set of pull-based publishers 330. Theillustrative push-based publishers 320 operate on a “push” model, suchthat messages are generated at the push-based publishers 320 andtransmitted to an intake ingestion buffer 306 (shown in FIG. 3B asprimary and secondary intake ingestion buffers 306A and 306B, which arediscussed in more detail below). As will be appreciated by one skilledin the art, “push” data transmission models generally correspond tomodels in which a data source determines when data should be transmittedto a data target. A variety of mechanisms exist to provide “push”functionality, including “true push” mechanisms (e.g., where a datasource independently initiates transmission of information) and“emulated push” mechanisms, such as “long polling” (a mechanism wherebya data target initiates a connection with a data source, but allows thedata source to determine within a timeframe when data is to betransmitted to the data source).

As shown in FIG. 3B, the push-based publishers 320 illustrativelyinclude an HTTP intake point 322 and a data intake and query system(DIQS) intake point 324. The HTTP intake point 322 can include acomputing device configured to obtain HTTP-based data (e.g., asJavaScript Object Notation, or JSON messages) to format the HTTP-baseddata as a message, to determine a topic for the message (e.g., based onfields within the HTTP-based data), and to publish the message to theprimary intake ingestion buffer 306A. Similarly, the DIQS intake point324 can be configured to obtain data from a forwarder 302, to format theforwarder data as a message, to determine a topic for the message, andto publish the message to the primary intake ingestion buffer 306A. Inthis manner, the DIQS intake point 324 can function in a similar mannerto the operations described with respect to the data retrieval subsystem304 of FIG. 3A.

In addition to the push-based publishers 320, one or more pull-basedpublishers 330 may be used to implement the data retrieval subsystem304. The pull-based publishers 330 may function on a “pull” model,whereby a data target (e.g., the primary intake ingestion buffer 306A)functions to continuously or periodically (e.g., each n seconds) querythe pull-based publishers 330 for new messages to be placed on theprimary intake ingestion buffer 306A. In some instances, development ofpull-based systems may require less coordination of functionalitybetween a pull-based publisher 330 and the primary intake ingestionbuffer 306A. Thus, for example, pull-based publishers 330 may be morereadily developed by third parties (e.g., other than a developer of thedata intake a query system 108), and enable the data intake and querysystem 108 to ingest data associated with third party data sources 202.Accordingly, FIG. 3B includes a set of custom intake points 332A through332N, each of which functions to obtain data from a third-party datasource 202, format the data as a message for inclusion in the primaryintake ingestion buffer 306A, determine a topic for the message, andmake the message available to the primary intake ingestion buffer 306Ain response to a request (a “pull”) for such messages.

While the pull-based publishers 330 are illustratively described asdeveloped by third parties, push-based publishers 320 may also in someinstances be developed by third parties. Additionally or alternatively,pull-based publishers may be developed by the developer of the dataintake and query system 108. To facilitate integration of systemspotentially developed by disparate entities, the primary intakeingestion buffer 306A may provide an API through which an intake pointmay publish messages to the primary intake ingestion buffer 306A.Illustratively, the API may enable an intake point to “push” messages tothe primary intake ingestion buffer 306A, or request that the primaryintake ingestion buffer 306A “pull” messages from the intake point.Similarly, the streaming data processors 308 may provide an API throughwhich ingestions buffers may register with the streaming data processors308 to facilitate pre-processing of messages on the ingestion buffers,and the output ingestion buffer 310 may provide an API through which thestreaming data processors 308 may publish messages or through whichdownstream devices or systems may subscribe to topics on the outputingestion buffer 310. Furthermore, any one or more of the intake points322 through 332N may provide an API through which data sources 202 maysubmit data to the intake points. Thus, any one or more of thecomponents of FIGS. 3A and 3B may be made available via APIs to enableintegration of systems potentially provided by disparate parties.

The specific configuration of publishers 320 and 330 shown in FIG. 3B isintended to be illustrative in nature. For example, the specific numberand configuration of intake points may vary according to embodiments ofthe present application. In some instances, one or more components ofthe intake system 210 may be omitted. For example, a data source 202 mayin some embodiments publish messages to an intake ingestion buffer 306,and thus an intake point 332 may be unnecessary. Other configurations ofthe intake system 210 are possible.

3.2.3. Ingestion Buffer(s)

The intake system 210 is illustratively configured to ensure messageresiliency, such that data is persisted in the event of failures withinthe intake system 210. Specifically, the intake system 210 may utilizeone or more ingestion buffers, which operate to resiliently maintaindata received at the intake system 210 until the data is acknowledged bydownstream systems or components. In one embodiment, resiliency isprovided at the intake system 210 by use of ingestion buffers thatoperate according to a publish-subscribe (“pub-sub”) message model. Inaccordance with the pub-sub model, data ingested into the data intakeand query system 108 may be atomized as “messages,” each of which iscategorized into one or more “topics.” An ingestion buffer can maintaina queue for each such topic, and enable devices to “subscribe” to agiven topic. As messages are published to the topic, the ingestionbuffer can function to transmit the messages to each subscriber, andensure message resiliency until at least each subscriber hasacknowledged receipt of the message (e.g., at which point the ingestionbuffer may delete the message). In this manner, the ingestion buffer mayfunction as a “broker” within the pub-sub model. A variety of techniquesto ensure resiliency at a pub-sub broker are known in the art, and thuswill not be described in detail herein. In one embodiment, an ingestionbuffer is implemented by a streaming data source. As noted above,examples of streaming data sources include (but are not limited to)Amazon's Simple Queue Service (“SQS”) or Kinesis™ services, devicesexecuting Apache Kafka™ software, or devices implementing the MessageQueue Telemetry Transport (MQTT) protocol. Any one or more of theseexample streaming data sources may be utilized to implement an ingestionbuffer in accordance with embodiments of the present disclosure.

With reference to FIG. 3A, the intake system 210 may include at leasttwo logical ingestion buffers: an intake ingestion buffer 306 and anoutput ingestion buffer 310. As noted above, the intake ingestion buffer306 can be configured to receive messages from the data retrievalsubsystem 304 and resiliently store the message. The intake ingestionbuffer 306 can further be configured to transmit the message to thestreaming data processors 308 for processing. As further describedbelow, the streaming data processors 308 can be configured with one ormore data transformation rules to transform the messages, and republishthe messages to one or both of the intake ingestion buffer 306 and theoutput ingestion buffer 310. The output ingestion buffer 310, in turn,may make the messages available to various subscribers to the outputingestion buffer 310, which subscribers may include the query system214, the indexing system 212, or other third-party devices (e.g., clientdevices 102, host devices 106, etc.).

Both the input ingestion buffer 306 and output ingestion buffer 310 maybe implemented on a streaming data source, as noted above. In oneembodiment, the intake ingestion buffer 306 operates to maintainsource-oriented topics, such as topics for each data source 202 fromwhich data is obtained, while the output ingestion buffer operates tomaintain content-oriented topics, such as topics to which the data of anindividual message pertains. As discussed in more detail below, thestreaming data processors 308 can be configured to transform messagesfrom the intake ingestion buffer 306 (e.g., arranged according tosource-oriented topics) and publish the transformed messages to theoutput ingestion buffer 310 (e.g., arranged according tocontent-oriented topics). In some instances, the streaming dataprocessors 308 may additionally or alternatively republish transformedmessages to the intake ingestion buffer 306, enabling iterative orrepeated processing of the data within the message by the streaming dataprocessors 308.

While shown in FIG. 3A as distinct, these ingestion buffers 306 and 310may be implemented as a common ingestion buffer. However, use ofdistinct ingestion buffers may be beneficial, for example, where ageographic region in which data is received differs from a region inwhich the data is desired. For example, use of distinct ingestionbuffers may beneficially allow the intake ingestion buffer 306 tooperate in a first geographic region associated with a first set of dataprivacy restrictions, while the output ingestion buffer 310 operates ina second geographic region associated with a second set of data privacyrestrictions. In this manner, the intake system 210 can be configured tocomply with all relevant data privacy restrictions, ensuring privacy ofdata processed at the data intake and query system 108.

Moreover, either or both of the ingestion buffers 306 and 310 may beimplemented across multiple distinct devices, as either a single ormultiple ingestion buffers. Illustratively, as shown in FIG. 3B, theintake system 210 may include both a primary intake ingestion buffer306A and a secondary intake ingestion buffer 306B. The primary intakeingestion buffer 306A is illustratively configured to obtain messagesfrom the data retrieval subsystem 304 (e.g., implemented as a set ofintake points 322 through 332N). The secondary intake ingestion buffer306B is illustratively configured to provide an additional set ofmessages (e.g., from other data sources 202). In one embodiment, theprimary intake ingestion buffer 306A is provided by an administrator ordeveloper of the data intake and query system 108, while the secondaryintake ingestion buffer 306B is a user-supplied ingestion buffer (e.g.,implemented externally to the data intake and query system 108).

As noted above, an intake ingestion buffer 306 may in some embodimentscategorize messages according to source-oriented topics (e.g., denotinga data source 202 from which the message was obtained). In otherembodiments, an intake ingestion buffer 306 may in some embodimentscategorize messages according to intake-oriented topics (e.g., denotingthe intake point from which the message was obtained). The number andvariety of such topics may vary, and thus are not shown in FIG. 3B. Inone embodiment, the intake ingestion buffer 306 maintains only a singletopic (e.g., all data to be ingested at the data intake and query system108).

The output ingestion buffer 310 may in one embodiment categorizemessages according to content-centric topics (e.g., determined based onthe content of a message). Additionally or alternatively, the outputingestion buffer 310 may categorize messages according toconsumer-centric topics (e.g., topics intended to store messages forconsumption by a downstream device or system). An illustrative number oftopics are shown in FIG. 3B, as topics 342 through 352N. Each topic maycorrespond to a queue of messages (e.g., in accordance with the pub-submodel) relevant to the corresponding topic. As described in more detailbelow, the streaming data processors 308 may be configured to processmessages from the intake ingestion buffer 306 and determine which topicsof the topics 342 through 352N into which to place the messages. Forexample, the index topic 342 may be intended to store messages, or datarecords, holding data that should be consumed and processed by theindexing system 212. The notable event topic 344 may be intended tostore messages holding data that indicates a notable event at a datasource 202 (e.g., the occurrence of an error or other notable event).The metrics topic 346 may be intended to store messages holding metricsdata for data sources 202. The search results topic 348 may be intendedto store messages holding data responsive to a search query. The mobilealerts topic 350 may be intended to store messages holding data forwhich an end user has requested alerts on a mobile device. A variety ofcustom topics 352A through 352N may be intended to hold data relevant toend-user-created topics.

As will be described below, by application of message transformationrules at the streaming data processors 308, the intake system 210 maydivide and categorize messages from the intake ingestion buffer 306,partitioning or sharding the messages into output topics relevant to aspecific downstream consumer. In this manner, specific portions of datainput to the data intake and query system 108 may be “divided out” andhandled separately, enabling different types of data to be handleddifferently, and potentially at different speeds. Illustratively, theindex topic 342 may be configured to include all or substantially alldata included in the intake ingestion buffer 306. Given the volume ofdata, there may be a significant delay (e.g., minutes or hours) before adownstream consumer (e.g., the indexing system 212) processes a messagein the index topic 342. Thus, for example, searching data processed bythe indexing system 212 may incur significant delay.

Conversely, the search results topic 348 may be configured to hold onlymessages corresponding to data relevant to a current query.Illustratively, on receiving a query from a client device 204, the querysystem 214 may transmit to the intake system 210 a rule that detects,within messages from the intake ingestion buffer 306A, data potentiallyrelevant to the query. The streaming data processors 308 may republishthese messages within the search results topic 348, and the query system214 may subscribe to the search results topic 348 in order to obtain thedata within the messages. In this manner, the query system 214 can“bypass” the indexing system 212 and avoid delay that may be caused bythat system, thus enabling faster (and potentially real time) display ofsearch results.

While shown in FIGS. 3A and 3B as a single output ingestion buffer 310,the intake system 210 may in some instances utilize multiple outputingestion buffers 310.

As described herein, in some embodiments, components of the intakesystem 210 can be reserved for a particular tenant or shared by multipletenants. In some such embodiments, a separate output ingestion buffer310 can be instantiated for each tenant or used by multiple tenants. Inembodiments, where an output ingestion buffer 310 is assigned to aparticular tenant, the output ingestion buffer 310 process data fromonly one tenant. In some such embodiments, the output ingestion buffer310 may not receive or process data from any other tenants.

In certain embodiments, the output ingestion buffer 310 can be shared bymultiple tenants. In some such embodiments, a partition or shard of theoutput ingestion buffer can 310 include data records associated withdifferent tenants. For example, a first shard can include data recordsassociated with Tenant A and Tenant B. As another example, the firstshard may only include data from Tenant A and a second shard may onlyinclude data from Tenant B. In either case, the output ingestion buffer310 can concurrently process data from different tenants. In some suchembodiments, the output ingestion buffer 310 can provide the data fromdifferent tenants to the same or different components of the indexingsystem 212. For example, as described herein, the indexing system 212,or certain components thereof, can be reserved for a particular tenantor shared across multiple tenants. Accordingly, the output ingestionbuffer 310 may provide the data to an indexing system 212 of aparticular tenant or an indexing system 212 that is shared by multipletenants.

3.2.4. Streaming Data Processors

As noted above, the streaming data processors 308 may apply one or morerules to process messages from the intake ingestion buffer 306A intomessages on the output ingestion buffer 310. These rules may bespecified, for example, by an end user of the data intake and querysystem 108 or may be automatically generated by the data intake andquery system 108 (e.g., in response to a user query).

Illustratively, each rule may correspond to a set of selection criteriaindicating messages to which the rule applies, as well as one or moreprocessing sub-rules indicating an action to be taken by the streamingdata processors 308 with respect to the message. The selection criteriamay include any number or combination of criteria based on the dataincluded within a message or metadata of the message (e.g., a topic towhich the message is published). In one embodiment, the selectioncriteria are formatted in the same manner or similarly to extractionrules, discussed in more detail below. For example, selection criteriamay include regular expressions that derive one or more values or asub-portion of text from the portion of machine data in each message toproduce a value for the field for that message. When a message islocated within the intake ingestion buffer 306 that matches theselection criteria, the streaming data processors 308 may apply theprocessing rules to the message. Processing sub-rules may indicate, forexample, a topic of the output ingestion buffer 310 into which themessage should be placed. Processing sub-rules may further indicatetransformations, such as field or unit normalization operations, to beperformed on the message. Illustratively, a transformation may includemodifying data within the message, such as altering a format in whichthe data is conveyed (e.g., converting millisecond timestamps values tomicrosecond timestamp values, converting imperial units to metric units,etc.), or supplementing the data with additional information (e.g.,appending an error descriptor to an error code). In some instances, thestreaming data processors 308 may be in communication with one or moreexternal data stores (the locations of which may be specified within arule) that provide information used to supplement or enrich messagesprocessed at the streaming data processors 308. For example, a specificrule may include selection criteria identifying an error code within amessage of the primary ingestion buffer 306A, and specifying that whenthe error code is detected within a message, that the streaming dataprocessors 308 should conduct a lookup in an external data source (e.g.,a database) to retrieve the human-readable descriptor for that errorcode, and inject the descriptor into the message. In this manner, rulesmay be used to process, transform, or enrich messages.

The streaming data processors 308 may include a set of computing devicesconfigured to process messages from the intake ingestion buffer 306 at aspeed commensurate with a rate at which messages are placed into theintake ingestion buffer 306. In one embodiment, the number of streamingdata processors 308 used to process messages may vary based on a numberof messages on the intake ingestion buffer 306 awaiting processing.Thus, as additional messages are queued into the intake ingestion buffer306, the number of streaming data processors 308 may be increased toensure that such messages are rapidly processed. In some instances, thestreaming data processors 308 may be extensible on a per topic basis.Thus, individual devices implementing the streaming data processors 308may subscribe to different topics on the intake ingestion buffer 306,and the number of devices subscribed to an individual topic may varyaccording to a rate of publication of messages to that topic (e.g., asmeasured by a backlog of messages in the topic). In this way, the intakesystem 210 can support ingestion of massive amounts of data fromnumerous data sources 202.

In some embodiments, an intake system may comprise a service accessibleto client devices 102 and host devices 106 via a network 104. Forexample, one type of forwarder may be capable of consuming vast amountsof real-time data from a potentially large number of client devices 102and/or host devices 106. The forwarder may, for example, comprise acomputing device which implements multiple data pipelines or “queues” tohandle forwarding of network data to indexers. A forwarder may alsoperform many of the functions that are performed by an indexer. Forexample, a forwarder may perform keyword extractions on raw data orparse raw data to create events. A forwarder may generate time stampsfor events. Additionally or alternatively, a forwarder may performrouting of events to indexers. Data store 208 may contain events derivedfrom machine data from a variety of sources all pertaining to the samecomponent in an IT environment, and this data may be produced by themachine in question or by other components in the IT environment.

3.3. Indexing System

FIGS. 4A and 4B are block diagrams illustrating embodiment of anindexing system 212. As described herein, in some embodiments, anindexing system 212 can be instantiated for each distinct tenant. Forexample, in some cases, the embodiment of the indexing system 212illustrated in FIG. 4A can be configured for a single tenant. In somesuch cases, each tenant can be assigned a separate indexing systemmanager 402, bucket manager 414, and indexing node(s) 404, includingseparate ingest manager(s) 406, partition managers 408, indexers 410,and data stores 412, etc. In such embodiments, the indexing node(s) 404,ingest manager(s) 406, and partition managers 408 may only process dataassociated with one tenant.

In certain embodiments, one or more components of the indexing systemcan be shared between multiple tenants. For example, in certain cases,the embodiment of the indexing system 212 illustrated in FIG. 4B can beconfigured for use by tenants. In some such cases, an ingest manager406, partition manager 408, and/or indexing node 404 may concurrentlyreceive and process data from multiple tenants. In addition, in theillustrated embodiment of FIG. 4B, the indexing system 212 can include aresource monitor 418 and a resource catalog 420.

It will be understood that the indexing system 212 can include fewer ormore components. For example, in some embodiments, the common storage216, the bucket manager 414, or the data store catalog 220 can form partof the indexing system 212, etc. In addition, although illustrated aspart of the indexing system 212, it will be understood that the resourcemonitor 418 and the resource catalog 420 can, in some embodiments, beseparate or independent of the indexing system 212. For example, incertain embodiments, the indexing system 212 and/or query system 214 cancommunicate with the resource monitor 418 and resource catalog 420similar to the way in which the indexing system 212 and query system 214can communicate with the data store catalog 220 and/or metadata catalog221.

As detailed herein, the ingestion buffer 310 communicates one or moredata streams to the indexing system 212 using multiple shards orpartitions. The data from a particular partition can be referred to as,or include, one or more data records. In some cases, the data recordsfrom a particular partition correspond to data associated with differenttenants, users, etc. In certain embodiments, the data records caninclude data to be processed by the indexing system 212 to generate oneor more events or location information of the data to be processed bythe indexing system 212 to generate one or more events. For example, thedata records can include a file identifier and a pointer to the locationof a file that includes the data to be processed by the indexing system212 to generate one or more events. In some embodiments, the datarecords can include a tenant identifier that identifies the tenantassociated with the file or data to be processed.

The indexing system 212 can receive, process, and store datacorresponding to the shards or partitions. For example, the indexingsystem 212 can generate events that include a portion of machine dataassociated with a timestamp and store the events in buckets based on oneor more of the timestamps, tenants, indexes, etc., associated with thedata. Moreover, the indexing system 212 can include various componentsthat enable it to provide a stateless indexing service, or indexingservice that is able to rapidly recover without data loss if one or morecomponents of the indexing system 212 become unresponsive orunavailable.

As described herein, each of the components of the indexing system 212can be implemented using one or more computing devices as distinctcomputing devices or as one or more container instances or virtualmachines across one or more computing devices. For example, in someembodiments, one or more the indexing system managers 402, the bucketmanagers 414, the resource catalog 420, the resource monitors 418, theingest managers 406, and/or the indexing nodes 404 can be implemented asdistinct computing devices with separate hardware, memory, andprocessors. In certain embodiments, one or more indexing system managers402, bucket managers 414, resource catalogs 420, resource monitors 418,ingest managers 406, and/or indexing nodes 404 can be implemented on thesame or across different computing devices as distinct containerinstances, with each container having access to a subset of theresources of a host computing device (e.g., a subset of the memory orprocessing time of the processors of the host computing device), butsharing a similar operating system. In some cases, the components can beimplemented as distinct virtual machines across one or more computingdevices, where each virtual machine can have its own unshared operatingsystem but shares the underlying hardware with other virtual machines onthe same host computing device.

3.3.1 Indexing System Manager

The indexing system manager 402 can monitor and manage the indexingnodes 404, and can be implemented as a distinct computing device,virtual machine, container, container of a pod, or a process or threadassociated with a container. For example, the indexing system manager402 can determine whether to generate an additional indexing node 404based on a utilization rate or availability of the indexing nodes 404.In certain embodiments, the indexing system 212 can include one indexingsystem manager 402 to manage all indexing nodes 404 of the indexingsystem 212. In some embodiments, the indexing system 212 can includemultiple indexing system managers 402 to manage the indexing nodes 404of the indexing system 212. For example, an indexing system manager 402can be instantiated for each computing device (or group of computingdevices) configured as a host computing device for multiple indexingnodes 404.

The indexing system manager 402 can handle resource management,creation/destruction of indexing nodes 404, high availability, loadbalancing, application upgrades/rollbacks, logging and monitoring,storage, networking, service discovery, and performance and scalability,and otherwise handle containerization management of the containers ofthe indexing system 212. In certain embodiments, the indexing systemmanager 402 can be implemented using Kubernetes or Swarm.

In some cases, the indexing system manager 402 can monitor the availableresources of a host computing device and request additional resources ina shared resource environment, based on workload of the indexing nodes404 or create, destroy, or reassign indexing nodes 404 based onworkload. Further, in some cases, the indexing system manager 402 systemcan assign indexing nodes 404 to handle data streams based on workload,system resources, etc. For example, in certain embodiments, the indexingsystem manager 402 can monitor or communicate with the resource catalog420 to identify workload of one or more of the indexing nodes 404.

In some embodiments, such as where ingest manager(s) 406 areinstantiated in a different isolated execution environment, container,or pod from the indexing nodes 404 (a non-limiting example isillustrated in FIG. 4B), the indexing system manager 402 can alsoperform any one or any combination of the aforementioned functions withrespect to the ingest manager(s) 406. In some such embodiments, theindexing system 212 can include one indexing system manager 402 tomanage the indexing nodes 404 and a second indexing system manager 402to manage the ingest managers 406. However, it will be understood thatin some cases a single indexing system manager 402 can manage theindexing nodes 404 and the ingest manager(s) 406 as desired.

3.3.2. Ingest Manager

One or more ingest managers 406 can receive the one or more data streamsfrom the partitions (or shards). Each ingest manager 406 can beimplemented as a distinct computing device, virtual machine, container,container of a pod, or a process or thread associated with a container.For example, in the illustrated embodiment of FIG. 4A, the ingestmanager 406 is shown as part of an indexing node 404, such as acontainer of an indexing node pod. As another example, in theillustrated embodiment of FIG. 4A, the ingest manager 406 is shown asbeing separate from the indexing nodes 404, such as a container or podthat is separate from the indexing node container or pod.

Depending on the architecture of the indexing system 212, the functionsof the ingest manager can vary. For example, when implemented as part ofan indexing node, the ingest manager 406 can be used to distribute thedata of one tenant between the indexing nodes 404 of that tenant. Insuch embodiments, the ingest manager can manage the processing of thedata of the data stream(s) of a tenant by the indexing nodes 404 of thattenant. In some such embodiments, each indexing node 404 can include oneor more ingest managers 406.

When instantiated separately from the indexing node 404, such as in ashared computing resource environment, the ingest manager(s) 406 can beused to distribute data associated with different tenants to differentindexing nodes 404. In addition, in some such embodiments, the ingestmanager(s) 406 be scaled separately or independently from the indexingnodes 404. For example, in some cases, the ingest manager 406 can have a1:1 correspondence to indexing nodes 404. In other cases, the ingestmanagers 406 can have a one-to-many or many-to-one correspondence toindexing nodes 404. As will be described herein, in some cases, wheninstantiated separately from the indexing nodes, the ingest manager (orpartition managers 408) can concurrently process data from multipletenants and communicate the data from multiple tenants to differentindexing nodes 404, each of which can concurrently process data fromdifferent tenants.

In certain embodiments, an ingest manager 406 can generate one or morepartition managers 408 to manage the partitions or streams of datareceived from the intake system 210. For example, the ingest manager 406can generate or assign a separate partition manager 408 for eachpartition or shard received from an output ingestion buffer 310. Asanother example, the ingest manager 406 can generate or assign a singlepartition manager 408 for multiple partitions.

In certain embodiments, data records can include a location marker. Forexample, the ingest manager 406 or partition manager 408 can receive(and/or store) the location markers in addition to or as part of thedata records received from the ingestion buffer 310. Accordingly, theingest manager 406 can track the location of the data in the ingestionbuffer 310 that the ingest manager 406 (for example, a partition manager408) has received from the ingestion buffer 310. In some embodiments,the ingest manager 406 stores the read pointers or location marker inone or more data stores, such as but not limited to, common storage 216,DynamoDB, S3, or another type of storage system, shared storage system,or networked storage system, etc. As the indexing nodes 404 are assignedto process data records, or as an indexing node 404 processes a datarecord, and the markers are updated by the intake system 210, the ingestmanager 406 can be updated to reflect the changes to the read pointersor location markers. In this way, if a partition manager 408 becomesunresponsive or unavailable, the ingest manager 406 can assign adifferent partition manager 408 to manage the data stream without losingcontext of what data is to be read from the intake system 210.Accordingly, in some embodiments, by using the ingestion buffer 310 andtracking the location of the location markers in the shards of theingestion buffer, the indexing system 212 can aid in providing astateless indexing service.

In some embodiments, such as where the ingest manager 406 is implementedas part of an indexing node 404, the ingest manager 406 can beimplemented as a background process, or daemon, in the indexing node 404and the partition managers 408 can be implemented as threads, copies, orforks of the background process. In some cases, an ingest manager 406can copy itself, or fork, to create a partition manager 408 or cause atemplate process to copy itself, or fork, to create each new partitionmanager 408, etc. This may be done for multithreading efficiency or forother reasons related to containerization and efficiency of managingindexers 410. In certain embodiments, the ingest manager 406 generates anew process for each partition manager 408. In some cases, by generatinga new process for each partition manager 408, the ingest manager 406 cansupport multiple language implementations and be language agnostic. Forexample, the ingest manager 406 can generate a process for a partitionmanager 408 in python and create a second process for a partitionmanager 408 in golang, etc.

3.3.3. Partition Manager

A partition manager 408 can manage the distribution of the data recordsreceived from one or more partitions or shards of the ingestion buffer310 to the indexing nodes 404. As mentioned, the ingest manager 406 cangenerate or assign one or more partition managers 408 for each partitionor shard, or can assign a single partition manager 408 for more than onepartition or shard. A partition manager 408 can be implemented as adistinct computing device, virtual machine, container, container of apod, or a process or thread associated with a container. In some cases,the partition manager 408 can be implemented as part of the indexingnode 404 (non-limiting example shown in FIG. 4A), as a sub-component ofthe ingest manager 406 (non-limiting example shown in FIG. 4B), or as aseparate component of the indexing system 212.

In some cases, managing the distribution of data records can include,but is not limited to, communicating one or more data records, orportions thereof, to an indexing node 404 (for example, to an indexer410) for processing, monitoring the indexing node 404, monitoring thesize of data being processed by the indexing node 404, instructing theindexing node 404 to move the data to common storage 216, or reportingthe storage of the data to the intake system 210.

A partition manager 408 can receive data records from one or morepartition(s) and can distribute the data records to one or more indexingnodes 404. In certain embodiments, such as the embodiment shown in FIG.4A, the partition manager 408 can assign data records to one or moreindexing nodes 404 based on their availability.

In some embodiments, such as the embodiment shown in FIG. 4B, thepartition manager 408 can communicate a data record to an indexing node404 for processing based on a data identifier associated with the datarecord. In certain embodiments, the data records received from apartition of the intake system can be associated with different dataidentifiers (non-limiting examples: tenant identifier, data sourceidentifier, sourcetype identifier, etc.). For example, the data recordsreceived from the ingestion buffer 310 can be associated with differenttenants. In some cases, using the data identifier, the partition manager408 can determine which indexing node 404 is to process a particulardata record. For example, based on a tenant identifier, the partitionmanager 408 can communicate data records associated with the same tenantto the same indexing node 404 (or group of indexing nodes 404).Accordingly, a particular partition manager 408 can process data recordsfrom different tenants, data sources, or with different sourcetypes.

In some embodiments, the partition manager 408 can determine whichindexing node 404 to process the data based on an indexing nodeassignment. In certain embodiments, the partition manager 408 candetermine the indexing node assignment itself or receive the indexingnode assignment from another component of the data intake and querysystem 108 or indexing system 212, such as the resource catalog 420 orresource monitor 418.

In some cases, the partition manager 408 can selectively and dynamicallydistribute data records associated with different tenants to differentindexing nodes 404 for processing. Furthermore, in certain embodiments,the partition manager 408 and/or ingest manager 406 can track whichindexing node 404 is assigned to process which data record. In this way,if an indexing node 404 fails or becomes unresponsive, the partitionmanager 408 can know which data records are to be reassigned to otherindexing nodes 404. In some embodiments, the partition manager 408receives data from a pub-sub messaging system, such as the ingestionbuffer 310. As described herein, the ingestion buffer 310 can have oneor more streams of data and one or more shards or partitions associatedwith each stream of data. Each stream of data can be separated intoshards and/or other partitions or types of organization of data. Incertain cases, each shard can include data from multiple tenants,indexes, etc. For example, one shard can include records from Tenants A,B, and C, and a second shard can include records from Tenants B, C, andD.

In some cases, each shard can correspond to data associated with aparticular tenant, index, source, sourcetype, etc. Accordingly, in someembodiments, the indexing system 212 can include a partition manager 408for individual tenants, indexes, sources, sourcetypes, etc. In somecases, based on the tenant identifier associated with a particular datarecord, the indexing system 212 can manage and process the datadifferently. For example, the indexing system 212 can assign moreindexing nodes 404 to process data from one tenant than another tenant,or store buckets associated with one tenant or index more frequently tocommon storage 216 than buckets associated with a different tenant orindex, etc.

In certain embodiments, each shard can include data associated withmultiple tenants, indexes, sources, or sourcetypes. In some suchembodiments, the partition manager 408 assigned to a particular shardcan concurrently process data associated with multiple tenants, indexes,sources, or sourcetypes.

In some embodiments, a partition manager 408 receives data from one ormore of the shards or partitions of the ingestion buffer 310. Thepartition manager 408 can forward one or more data records from theshards/partitions to indexing nodes 404 for processing. In some cases,the amount or size of the data record(s) coming through a partition mayexceed the partition's (or ingestion buffer's 310) throughput. Forexample, 4 MB/s of data records may be sent to an ingestion buffer 310for a particular partition, but the ingestion buffer 310 may be able toprocess only 2 MB/s of data per partition. Additionally, some systems oruser policies may artificially limit an amount of data throughput pershard. Accordingly, in some embodiments, one or more data records caninclude a reference to a location in storage where the indexing node 404can retrieve data. For example, a reference pointer to the data to beprocessed can be placed in the ingestion buffer 310 rather than puttingthe data to be processed itself into the ingestion buffer 310. Thereference pointer can reference a chunk of data or a file that is largerthan the throughput of the ingestion buffer 310 for that partition. Inthis way, the data intake and query system 108 can increase thethroughput of individual partitions of the ingestion buffer 310. In someembodiments, the partition manager 408 can obtain the reference pointerfrom the ingestion buffer 310 and retrieve data from the referencedstorage for processing. In certain embodiments, the partition manager408 forwards the data record with the reference pointer to the indexingnode 404 and the indexing node 404 retrieves the data from thereferenced storage location. In some cases, the referenced storage towhich reference pointers in the ingestion buffer 310 point cancorrespond to the common storage 216 or other shared storage or localstorage. In some implementations, the chunks of data to which thereference pointers refer may be directed to common storage 216 fromintake system 210, e.g., streaming data processor 308 or ingestionbuffer 310.

In certain embodiments, as an indexing node 404 processes the datarecord(s), stores the data in buckets, and generates indexes of thedata, the partition manager(s) 408 can monitor the indexing node 404(and/or the indexer(s) 410). For example, a partition manager 408 canmonitor the size of the data on an indexer 410 (inclusive or exclusiveof the data store 412). In some cases, the size of the data on anindexer 410 can correspond to the data that is actually received fromthe particular partition of the intake system 210 (or retrieved usingthe data received from the particular partition), as well as datagenerated by the indexer 410 based on the received data (e.g., invertedindexes, summaries, etc.), and may correspond to one or more buckets.For instance, the indexer 410 may have generated one or more buckets foreach tenant and/or index associated with data being processed in theindexer 410. In some cases, such as when multiple indexers 410 processthe data records from the same index, the aggregated size of the data oneach of those indexers 410 can correspond to the data that is actuallyreceived from the particular partition of the intake system 210, as wellas data generated by the indexers 410 based on the received data.

Based on a bucket roll-over policy, the partition manager 408 caninstruct the indexer(s) 410 to convert editable groups of data orbuckets to non-editable groups or buckets and/or copy the dataassociated with the partition to common storage 216. In someembodiments, the bucket roll-over policy can indicate that the data,which may have been indexed by the indexer(s) 410 and stored in the datastore 412 in various buckets, is to be copied to common storage 216based on a determination that the size of the data satisfies a thresholdsize. In some cases, the bucket roll-over policy can include differentthreshold sizes for different data associated with different dataidentifiers identifying different tenants, data sources, sourcetypes,hosts, users, partitions, partition managers, or the like. In someimplementations, the bucket roll-over policy may be modified by otherfactors, such as an identity of a tenant associated with one or moreindexing nodes 404, system resource usage, which could be based on thepod(s) or other container(s) that contain the indexing node(s) 404, orone of the physical hardware layers with which the indexing node(s) 404are running, or any other appropriate factor for scaling and systemperformance of indexing nodes 404 or any other system component.

In certain embodiments, the bucket roll-over policy can indicate data isto be copied to common storage 216 based on a determination that theamount of data (or a subset thereof) of the indexing node 404 satisfiesa threshold amount. Further, the bucket roll-over policy can indicatethat the one or more partition managers 408 or an indexing node 404 areto communicate with each other or with the ingest manager 406 or theingest manager 406 to monitor the amount of data on the indexer 410assigned to the indexing node 404 and determine that the amount of dataon the indexer 410 (or data store 412) satisfies a threshold amount.Accordingly, based on the bucket roll-over policy, one or more of thepartition managers 408 or the ingest manager 406 or the ingest manager406 can instruct the indexer 410 to convert editable buckets tonon-editable buckets and/or store the data.

In certain embodiments, the bucket roll-over policy can indicate thatbuckets are to be converted to non-editable buckets and stored in commonstorage 216 based on a collective size of buckets satisfying a thresholdsize. In some cases, the bucket roll-over policy can use differentthreshold sizes for conversion and storage. For example, the bucketroll-over policy can use a first threshold size to indicate wheneditable buckets are to be converted to non-editable buckets (e.g., stopwriting to the buckets) and a second threshold size to indicate when thedata (or buckets) are to be stored in common storage 216. In certaincases, the bucket roll-over policy can indicate that the partitionmanager(s) 408 are to send a single command to the indexing node(s) 404or the indexer(s) 410 that causes the indexer(s) 410 to convert editablebuckets to non-editable buckets and store the buckets in common storage216.

The bucket roll-over policy can use other criteria to determine whenbuckets are to be converted and stored to common storage 216. Forexample, the bucket roll-over policy can indicate that buckets are to berolled over at predetermined or dynamic time intervals with or withoutregard to size, etc.

Any one or any combination of the aforementioned bucket roll-overpolicies can be used for different data. In some cases, the indexers 410can use different bucket roll-over policies for buckets associated withdifferent data identifiers. For example, the bucket roll-over policy forbuckets associated with Tenant A can use one threshold for determiningwhen to roll buckets over to common storage and the bucket roll-overpolicy for buckets associated with Tenant B can use a differentthreshold. Accordingly, it will be understood that the indexers 410and/or partition manager 408 can concurrently use/apply different bucketroll-over policies to different buckets.

Based on an acknowledgement that the data associated with a tenant, datasource, sourcetype, host, user, partition, partition manager, or thelike, has been stored in common storage 216, the partition manager 408can communicate to the intake system 210, either directly or through theingest manager 406 that the data has been stored and/or that thelocation marker or read pointer can be moved or updated. In some cases,the partition manager 408 receives the acknowledgement that the data hasbeen stored from common storage 216 and/or from the indexing node 404,such as from the indexer 410. In certain embodiments, which will bedescribed in more detail herein, the intake system 210 does not receivea communication that the data stored in intake system 210 has been readand processed until after that data has been stored in common storage216.

The acknowledgement that the data has been stored in common storage 216can also include location information about the data within the commonstorage 216. For example, the acknowledgement can provide a link, map,or path to the copied data in the common storage 216. Using theinformation about the data stored in common storage 216, the partitionmanager 408 can update the data store catalog 220. For example, thepartition manager 408 can update the data store catalog 220 with anidentifier of the data (e.g., bucket identifier, tenant identifier,partition identifier, etc.), the location of the data in common storage216, a time range associated with the data, etc. In this way, the datastore catalog 220 can be kept up-to-date with the contents of the commonstorage 216.

Moreover, as additional data is received from the intake system 210, thepartition manager 408 can continue to communicate the data to theindexing nodes 404, monitor the size or amount of data on an indexer410, instruct an indexer 410 to copy the data to common storage 216,communicate the successful storage of the data to the intake system 210,and update the data store catalog 220.

As a non-limiting example, consider the scenario in which the intakesystem 210 communicates a plurality of data records from a particularpartition to the indexing system 212. The intake system 210 can trackwhich data it has sent and a location marker for the data in the intakesystem 210 (e.g., a marker that identifies data that has been sent tothe indexing system 212 for processing).

As described herein, the intake system 210 can retain or persistentlymake available the sent data until the intake system 210 receives anacknowledgement from the indexing system 212 that the sent data has beenprocessed, stored in persistent storage (e.g., common storage 216), oris safe to be deleted. In this way, if an indexing node 404, ingestmanager 406, or partition manager 408 assigned to process the sent databecomes unresponsive or is lost, e.g., due to a hardware failure or acrash, the data that was sent to the unresponsive component will not belost. Rather, a different indexing node 404, ingest manager 406, orpartition manager 408, can obtain and process the data from the intakesystem 210.

In some embodiments, as the data records from a partition of the ingestbuffer 310 may be processed by different indexing nodes 404, the intakesystem 210 can retain or persistently make available a data record untilthe intake system 210 receives an acknowledgement from the indexingsystem 212 that the data record and other data records sent prior to thedata record from the same partition have been processed. For example, ifdata records 1-5 are sent (in that order) to a partition manager 408 anddistributed to five indexing nodes 404, the intake system 210 can retaindata record 5 until it receives an acknowledgement that data records 1-4have been processed and relevant data is stored in common storage 216.The intake system 210 can retain data record 5 even if the correspondingindexing node 404 completes its processing of data record 5 before theother indexing nodes 404 complete the processing of data records 1-4.

As the indexing system 212 stores the data in common storage 216, it canreport the storage to the intake system 210. In response, the intakesystem 210 can update its marker to identify different data that hasbeen sent to the indexing system 212 for processing, but has not yetbeen stored. By moving the marker, the intake system 210 can indicatethat the previously-identified data has been stored in common storage216, can be deleted from the intake system 210 or, otherwise, can beallowed to be overwritten, lost, etc. In certain embodiments, theindexing system 212 can report the storage of a particular data recordonce it determines that any records received prior to it from the samepartition have also been stored.

With reference to the example above, in some embodiments, the ingestmanager 406 can track the marker used by the ingestion buffer 310, andthe partition manager 408 can receive data records from the ingestionbuffer 310 and forward one or more data records to an indexing node 404,for example to an indexer 410, for processing (or use the data in theingestion buffer to obtain data from a referenced storage location andforward the obtained data to the indexer). The partition manager 408 canmonitor the amount of data being processed and instruct the indexingnode 404 to copy the data to common storage 216. Once the data is storedin common storage 216, the partition manager 408 can report the storageto the ingestion buffer 310, so that the ingestion buffer 310 can updateits marker. In addition, the ingest manager 406 can update its recordswith the location of the updated marker. In this way, if partitionmanager 408 become unresponsive or fails, the ingest manager 406 canassign a different partition manager 408 to obtain the data from thedata stream without losing the location information, or if the indexer410 becomes unavailable or fails, the ingest manager 406 can assign adifferent indexer 410 to process and store the data.

In some cases, the partition manager 408 dynamically distributes datarecords to different indexing nodes based on an indexing nodeassignment. In some embodiments, the partition manager 408 receives anindexing node assignment from the resource monitor 418, or othercomponent of the data intake and query system 108 to determine whichindexing node 404 to forward a data record. In certain embodiments, thepartition manager 408 can determine the indexing node assignment itselfor include or consult an indexing node assignment listing that storesrecent indexing node assignments. The table or list can be stored as alookup table or in a database, etc.

In certain embodiments, the partition manager 408 can consult theindexing node assignment listing to determine whether a data identifier(non-limiting example: tenant identifier) relating to a particular datarecord to be distributed to an indexing node is already associated witha particular indexing node 404 or group of indexing nodes 404. If it is,the partition manager 408 can communicate the particular data record tothe particular indexing node 404. If it is not, the partition manager408 can determine the indexing node assignment or request one from theresource monitor 418, or other component of the data intake and querysystem 108 to determine which indexing node 404 to forward a datarecord.

In some cases, the indexing node assignment listing can include anindication of the data identifiers associated with data records thathave been assigned to an indexing node 404 over a certain period oftime, such as the last 15, 30, 60, or 90 seconds. In some cases, theindexing node assignment listing is cleared or deleted periodically,such as every 15, 30, 60, or 90 seconds be updated. In this way, theindexing node assignment listing can store the more recent indexing nodeassignments.

In some cases, a different indexing node assignment listing can bestored on or associated with each different partition manager 408. Forexample, a particular partition manager 408 can manage its own indexingnode assignment listing by cataloging the indexing node assignments,which in some embodiments, can be received from the resource catalog420. As another example, the ingest manager 406 can manage some or allof the indexing node assignment listings of the partition managers 408.In some cases, an indexing node assignment listing can be associatedwith some or all of the partition managers 408. For example, the ingestmanager 406 or the partition managers 408 can manage the indexing nodeassignment listing by cataloging the indexing node assignments for allof the partition managers 408 associated with the ingest manager 406.

3.3.4. Indexing Nodes

The indexing nodes 404 can include one or more components to implementvarious functions of the indexing system 212. For example, in theillustrated embodiment of FIG. 4A, the indexing node 404 includes one ormore ingest managers 406, partition managers 408, indexers 410, datastores 412, and/or bucket managers 414. As another example, in theillustrated embodiment of FIG. 4B, the indexing node 404 includes anindexer 410, a data store 412, and a bucket manager 414. As describedherein, the indexing nodes 404 can be implemented on separate computingdevices or as containers or virtual machines in a virtualizationenvironment.

In some embodiments, an indexing node 404, can be implemented as adistinct computing device, virtual machine, container, pod, or a processor thread associated with a container, or using multiple-relatedcontainers. In certain embodiments, such as in a Kubernetes deployment,each indexing node 404 can be implemented as a separate container orpod. For example, one or more of the components of the indexing node 404can be implemented as different containers of a single pod, e.g., on acontainerization platform, such as Docker, the one or more components ofthe indexing node can be implemented as different Docker containersmanaged by synchronization platforms such as Kubernetes or Swarm.Accordingly, reference to a containerized indexing node 404 can refer tothe indexing node 404 as being a single container or as one or morecomponents of the indexing node 404 being implemented as different,related containers or virtual machines.

In certain embodiments, each indexing node 404 can include a monitoringmodule. In some cases, the monitoring modulate can communicate one ormore of an indexing node identifier, metrics, status identifiers,network architecture data, or indexing node assignments to the resourcemonitor 418. For example, as described herein, the monitoring module canindicate a utilization rate of an indexing node 404, an amount ofprocessing resources in use by an indexing node 404, an amount of memoryused by an indexing node 404, an availability or responsiveness of anindexing node 404, etc.

3.3.4.1. Indexer and Data Store

As described herein, the indexer 410 can be the primary indexingexecution engine, and can be implemented as a distinct computing device,container, container within a pod, etc. For example, the indexer(s) 410can be tasked with parsing, processing, indexing, and storing the datareceived from the intake system 210 via the partition manager(s) 408.Specifically, in some embodiments, the indexer 410 can parse theincoming data to identify timestamps, generate events from the incomingdata, group and save events into buckets, generate summaries or indexes(e.g., time series index, inverted index, keyword index, etc.) of theevents in the buckets, and store the buckets in common storage 216.

As used herein, an index can refer to different data structures. In somecases, index can refer to a logical division of data similar to apartition. In certain cases, index can refer to a data structure, suchas a file, that stores information about other data (non-limitingexamples: a time series index, inverted index, keyword index). Inaddition, when used as a verb, index can refer to the processing and/orstoring of data by the indexing system 212 and/or intake system 210. Forexample, in some cases, the indexing system 212 can index dataassociated with a particular index (non-limiting example: main index) togenerate events and one or more indexes that include information aboutthe generated events (non-limiting example: time series index). As partof the indexing, the generated events and indexes can be stored as partof or in association with the particular index. In some cases, oneindexer 410 can be assigned to each partition manager 408 such that thesingle indexer 410 processes some or all of the data from its assignedpartition manager 408. In certain embodiments, one indexer 410 canreceive and process the data from multiple partition managers 408 in theindexing system. For example, with reference to FIG. 4A, one indexer 410can receive and process the data from partition managers 408 on the sameindexing node 404, on multiple indexing nodes 404, on the same ingestmanager 406, or multiple ingest managers 406. As another example, withreference to FIG. 4B, an indexer 410 can receive and process data frommultiple partition managers 408 and/or ingest managers 406. In somecases, multiple indexing nodes 404 or indexers 410 can be assigned to asingle partition manager 408. In certain embodiments, the multipleindexing nodes 404 or indexers 410 can receive and process the datareceived from the single partition manager 408, as well as data fromother partition managers 408.

In some embodiments, the indexer 410 can store the events and buckets inthe data store 412 according to a bucket creation policy. The bucketcreation policy can indicate how many buckets the indexer 410 is togenerate for the data that it processes. In some cases, based on thebucket creation policy, the indexer 410 generates at least one bucketfor each unique combination of a tenant and index (which may also bereferred to as a partition) associated with the data that it processes.For example, if the indexer 410 receives data associated with threetenants A, B, C, then the indexer 410 can generate at least threebuckets: at least one bucket for each of Tenant A, Tenant B, and TenantC. As another example, if the indexer 410 receives data associated withindex A of Tenant A from one partition or shard, and receives dataassociated with index A of Tenant A and index B of Tenant B from asecond partition or shard, then the indexer 410 can generate at leasttwo buckets: at least one bucket for Tenant A (including datacorresponding to index A from partition 1 and partition 2) and Tenant B(including data corresponding to index B from partition 2).

In some cases, based on the bucket creation policy, the indexer 410generates at least one bucket for each combination of tenant and indexassociated with the data that it processes. For example, if the indexer410 receives data associated with three tenants A, B, C, each with twoindexes X, Y, then the indexer 410 can generate at least six buckets: atleast one bucket for each of Tenant A::Index X, Tenant A::Index Y,Tenant B::Index X, Tenant B::Index Y, Tenant C::Index X, and TenantC::Index Y. Additional buckets may be generated for a tenant/index pairbased on the amount of data received that is associated with thetenant/partition pair. It will be understood that the indexer 410 cangenerate buckets using a variety of policies. For example, the indexer410 can generate one or more buckets for each tenant, partition, source,sourcetype, etc.

In some cases, if the indexer 410 receives data that it determines to be“old,” e.g., based on a timestamp of the data or other temporaldetermination regarding the data, then it can generate a bucket for the“old” data. In some embodiments, the indexer 410 can determine that datais “old,” if the data is associated with a timestamp that is earlier intime by a threshold amount than timestamps of other data in thecorresponding bucket (e.g., depending on the bucket creation policy,data from the same partition and/or tenant) being processed by theindexer 410. For example, if the indexer 410 is processing data for thebucket for Tenant A::Index X having timestamps on 4/23 between 16:23:56and 16:46:32 and receives data for the Tenant A::Index X bucket having atimestamp on 4/22 or on 4/23 at 08:05:32, then it can determine that thedata with the earlier timestamps is “old” data and generate a new bucketfor that data. In this way, the indexer 410 can avoid placing data inthe same bucket that creates a time range that is significantly largerthan the time range of other buckets, which can decrease the performanceof the system as the bucket could be identified as relevant for a searchmore often than it otherwise would.

The threshold amount of time used to determine if received data is“old,” can be predetermined or dynamically determined based on a numberof factors, such as, but not limited to, time ranges of other buckets,amount of data being processed, timestamps of the data being processed,etc. For example, the indexer 410 can determine an average time range ofbuckets that it processes for different tenants and indexes. If incomingdata would cause the time range of a bucket to be significantly larger(e.g., 25%, 50%, 75%, double, or other amount) than the average timerange, then the indexer 410 can determine that the data is “old” data,and generate a separate bucket for it. By placing the “old” bucket in aseparate bucket, the indexer 410 can reduce the instances in which thebucket is identified as storing data that may be relevant to a query.For example, by having a smaller time range, the query system 214 mayidentify the bucket less frequently as a relevant bucket then if thebucket had the large time range due to the “old” data. Additionally, ina process that will be described in more detail herein, time-restrictedsearches and search queries may be executed more quickly because theremay be fewer buckets to search for a particular time range. In thismanner, computational efficiency of searching large amounts of data canbe improved. Although described with respect detecting “old” data, theindexer 410 can use similar techniques to determine that “new” datashould be placed in a new bucket or that a time gap between data in abucket and “new” data is larger than a threshold amount such that the“new” data should be stored in a separate bucket.

In some cases, based on a bucket roll-over policy, the indexer 410periodically determines to convert editable groups of data or buckets tonon-editable groups or buckets and/or copy the data associated with thepartition or tenant identifier to common storage 216. For example, thebucket roll-over policy may indicate a time-based schedule so that theindexer 410 determines to copy and/or store the data every X number ofseconds, or every X minute(s), and so forth.

In some embodiments, the bucket roll-over policy can indicate that thedata, which may have been indexed by the indexer(s) 410 and stored inthe data store 412 in various buckets, is to be copied to common storage216 based on a determination that the size of the data satisfies athreshold size. In some cases, the bucket roll-over policy can includedifferent threshold sizes for different data associated with differentdata identifiers identifying different tenants, data sources,sourcetypes, hosts, users, partitions, partition managers, or the like.The threshold amount can correspond to the amount of data beingprocessed by the indexer 410 for any partition or any tenant identifier.

In some cases, the bucket roll-over policy may indicate that one or morebuckets are to be rolled over based on a combination of a time-basedschedule and size. For example, the bucket roll-over policy may indicatea time-based schedule in combination with a data threshold. For example,the indexer 410 can determine to copy the data to common storage 216based on a determination that the amount of data stored on the indexer410 satisfies a threshold amount or a determination that the data hasnot been copied in X number of seconds, X number of minutes, etc.Accordingly, in some embodiments, the indexer 410 can determine that thedata is to be copied to common storage 216 without communication withthe partition manager 408 or the ingest manager 416. In someimplementations, the bucket roll-over policy may be modified by otherfactors, such as an identity of a tenant associated with one or moreindexing nodes 404, system resource usage, which could be based on thepod(s) or other container(s) that contain the indexing node(s) 404, orone of the physical hardware layers with which the indexing node(s) 404are running, or any other appropriate factor for scaling and systemperformance of indexing nodes 404 or any other system component.

In certain embodiments, the partition manager 408 can instruct theindexer 410 to copy the data to common storage 216 based on a bucketroll-over policy. For example, the partition manager 408 can monitor thesize of the buckets and instruct the indexer 410 to copy the bucket tocommon storage 216. The threshold size can be predetermined ordynamically determined.

In certain embodiments, the partition manager 408 can monitor the sizeof multiple, or all, buckets associated with the indexes, indexingnode(s) 404, or indexer(s) 410 being managed by the partition manager408, and based on the collective size of the buckets satisfying athreshold size, instruct the indexer 410 to copy the buckets associatedwith the index to common storage 216. In certain cases, one or morepartition managers 408, or ingest managers 406 can monitor the size ofbuckets across multiple, or all indexes, associated with one or moreindexing nodes 404, and instruct the indexer(s) 410 to copy the bucketsto common storage 216 based on the size of the buckets satisfying athreshold size.

As described herein, buckets in the data store 412 that are being editedby an indexer 410 can be referred to as hot buckets or editable buckets.For example, an indexer 410 can add data, events, and indexes toeditable buckets in the data store 412, etc. Buckets in the data store412 that are no longer edited by an indexer 410 can be referred to aswarm buckets or non-editable buckets. In some embodiments, once anindexer 410 determines that a hot bucket is to be copied to commonstorage 216, it can convert the hot (editable) bucket to a warm(non-editable) bucket, and then move or copy the warm bucket to thecommon storage 216 based on a bucket roll-over policy. Once the warmbucket is moved or copied to common storage 216, an indexer 410 cannotify a partition manager 408 that the data associated with the warmbucket has been processed and stored. As mentioned, a partition manager408 can relay the information to the intake system 210. In addition, anindexer 410 can provide a partition manager 408 with information aboutthe buckets stored in common storage 216, such as, but not limited to,location information, tenant identifier, index identifier, time range,etc. As described herein, a partition manager 408 can use thisinformation to update the data store catalog 220. In certainembodiments, the indexer 410 can update the data store catalog 220. Forexample, the indexer 410 can update the data store catalog 220 based onthe information it receives from the common storage 216 about the storedbuckets.

3.3.4.2. Bucket Manager

The bucket manager 414 can manage the buckets stored in the data store412, and can be implemented as a distinct computing device, virtualmachine, container, container of a pod, or a process or threadassociated with a container. In some cases, the bucket manager 414 canbe implemented as part of the indexer 410, indexing node 404, the ingestmanager 406, or as a separate component of the indexing system 212.

As described herein, the indexer 410 stores data in the data store 412as one or more buckets associated with different tenants, indexes, etc.In some cases, the contents of the buckets are not searchable by thequery system 214 until they are stored in common storage 216. Forexample, the query system 214 may be unable to identify data responsiveto a query that is located in hot (editable) buckets in the data store412 and/or the warm (non-editable) buckets in the data store 412 thathave not been copied to common storage 216. Thus, query results may beincomplete or inaccurate, or slowed as the data in the buckets of thedata store 412 are copied to common storage 216.

To decrease the delay between processing and/or indexing the data andmaking that data searchable, the indexing system 212 can use a bucketroll-over policy that instructs the indexer 410 to convert hot bucketsto warm buckets more frequently (or convert based on a smaller thresholdsize) and/or copy the warm buckets to common storage 216. Whileconverting hot buckets to warm buckets more frequently or based on asmaller storage size can decrease the lag between processing the dataand making it searchable, it can increase the storage size and overheadof buckets in common storage 216. For example, each bucket may haveoverhead associated with it, in terms of storage space required,processor power required, or other resource requirement. Thus, morebuckets in common storage 216 can result in more storage used foroverhead than for storing data, which can lead to increased storage sizeand costs. In addition, a larger number of buckets in common storage 216can increase query times, as the opening of each bucket as part of aquery can have certain processing overhead or time delay associated withit.

To decrease search times and reduce overhead and storage associated withthe buckets (while maintaining a reduced delay between processing thedata and making it searchable), the bucket manager 414 can monitor thebuckets stored in the data store 412 and/or common storage 216 and mergebuckets according to a bucket merge policy. For example, the bucketmanager 414 can monitor and merge warm buckets stored in the data store412 before, after, or concurrently with the indexer copying warm bucketsto common storage 216.

The bucket merge policy can indicate which buckets are candidates for amerge or which bucket to merge (e.g., based on time ranges, size,tenant, index, or other identifiers), the number of buckets to merge,size or time range parameters for the merged buckets, and/or a frequencyfor creating the merged buckets. For example, the bucket merge policycan indicate that a certain number of buckets are to be merged,regardless of size of the buckets. As another non-limiting example, thebucket merge policy can indicate that multiple buckets are to be mergeduntil a threshold bucket size is reached (e.g., 750 MB, or 1 GB, ormore). As yet another non-limiting example, the bucket merge policy canindicate that buckets having a time range within a set period of time(e.g., 30 sec, 1 min., etc.) are to be merged, regardless of the numberor size of the buckets being merged.

In addition, the bucket merge policy can indicate which buckets are tobe merged or include additional criteria for merging buckets. Forexample, the bucket merge policy can indicate that only buckets havingthe same tenant identifier and/or index are to be merged, or setconstraints on the size of the time range for a merged bucket (e.g., thetime range of the merged bucket is not to exceed an average time rangeof buckets associated with the same source, tenant, partition, etc.). Incertain embodiments, the bucket merge policy can indicate that bucketsthat are older than a threshold amount (e.g., one hour, one day, etc.)are candidates for a merge or that a bucket merge is to take place oncean hour, once a day, etc. In certain embodiments, the bucket mergepolicy can indicate that buckets are to be merged based on adetermination that the number or size of warm buckets in the data store412 of the indexing node 404 satisfies a threshold number or size, orthe number or size of warm buckets associated with the same tenantidentifier and/or partition satisfies the threshold number or size. Itwill be understood, that the bucket manager 414 can use any one or anycombination of the aforementioned or other criteria for the bucket mergepolicy to determine when, how, and which buckets to merge.

Once a group of buckets is merged into one or more merged buckets, thebucket manager 414 can copy or instruct the indexer 410 to copy themerged buckets to common storage 216. Based on a determination that themerged buckets are successfully copied to the common storage 216, thebucket manager 414 can delete the merged buckets and the buckets used togenerate the merged buckets (also referred to herein as unmerged bucketsor pre-merged buckets) from the data store 412 according to a bucketmanagement policy.

In some cases, the bucket manager 414 can also remove or instruct thecommon storage 216 to remove corresponding pre-merged buckets from thecommon storage 216 according to the bucket management policy. The bucketmanagement policy can indicate when the pre-merged buckets are to bedeleted or designated as able to be overwritten from common storage 216and/or in the data store 412.

In some cases, the bucket management policy can indicate that thepre-merged buckets are to be deleted immediately, once any queriesrelying on the pre-merged buckets are completed, after a predeterminedamount of time, etc. Further, the bucket management policy can indicatedifferent criteria for deleting data from common storage 216 and/or thedata store 412.

In some cases, the pre-merged buckets may be in use or identified foruse by one or more queries. Removing the pre-merged buckets from commonstorage 216 in the middle of a query may cause one or more failures inthe query system 214 or result in query responses that are incomplete orerroneous. Accordingly, the bucket management policy, in some cases, canindicate to the common storage 216 that queries that arrive before amerged bucket is stored in common storage 216 are to use thecorresponding pre-merged buckets and queries that arrive after themerged bucket is stored in common storage 216 are to use the mergedbucket.

Further, the bucket management policy can indicate that once queriesusing the pre-merged buckets are completed, the buckets are to beremoved from common storage 216. However, it will be understood that thebucket management policy can indicate removal of the buckets in avariety of ways. For example, per the bucket management policy, thecommon storage 216 can remove the buckets after on one or more hours,one day, one week, etc., with or without regard to queries that may berelying on the pre-merged buckets. In some embodiments, the bucketmanagement policy can indicate that the pre-merged buckets are to beremoved without regard to queries relying on the pre-merged buckets andthat any queries relying on the pre-merged buckets are to be redirectedto the merged bucket. It will be understood that the bucket manager 414can use different bucket management policies for data associated withdifferent data identifiers. For example, the bucket manager 414 can useone bucket management policy for data associated with a first tenant anduse another bucket management policy for data associated with a secondtenant. In this way, the bucket manager can concurrently use differentbucket management policies for different data.

In addition to removing the pre-merged buckets and merged bucket fromthe data store 412 and removing or instructing common storage 216 toremove the pre-merged buckets from the data store(s) 218, the bucketmanager 414 can update the data store catalog 220 or cause the indexer410 or partition manager 408 to update the data store catalog 220 withthe relevant changes. These changes can include removing reference tothe pre-merged buckets in the data store catalog 220 and/or addinginformation about the merged bucket, including, but not limited to, abucket, tenant, and/or partition identifier associated with the mergedbucket, a time range of the merged bucket, location information of themerged bucket in common storage 216, etc. In this way, the data storecatalog 220 can be kept up-to-date with the contents of the commonstorage 216.

3.3.5. Resource Catalog

The resource catalog 420 can store information relating to the indexingnodes 404 of the indexing system 212, such as, but not limited to,indexing node identifiers, metrics, status identifiers, networkarchitecture data, or indexing node assignments. The resource catalog420 can be maintained (for example, populated, updated, etc.) by theresource monitor 418. As mentioned, in some embodiments, the resourcemonitor 418 and resource catalog 420 can be separate or independent ofthe indexing system 212.

In some cases, the resource catalog 420 includes one or more indexingnode identifiers. As mentioned, the indexing system 212 can include aplurality of indexing nodes 404. In some cases, the resource catalog 420can include a different indexing node identifier for each indexing node404 of the indexing system 212. In some cases, for example if theresource monitor 418 or the indexing system manager 402 generates a newindexing node 404, the resource monitor 418 can update the resourcecatalog 420 to include an indexing node identifier associated with thenew indexing node 404. In some cases, for example, if an indexing node404 is removed from the indexing system 212 or the indexing node 404becomes unresponsive or unavailable, the resource monitor 418 can updatethe resource catalog 420 to remove an indexing node identifierassociated with that indexing node 404. In this way, the resourcecatalog 420 can include up-to-date information relating to whichindexing nodes 404 are instantiated in the indexing system 212.

In some cases, the resource catalog 420 includes one or more metricsassociated with one or more of the indexing nodes 404 in the indexingsystem 212. For example, the metrics can include, but are not limitedto, one or more performance metrics such as CPU-related performancemetrics, memory-related performance metrics, availability performancemetrics, or the like. For example, the resource catalog 420 can includeinformation relating to a utilization rate of an indexing node 404, suchas an indication of which indexing nodes 404, if any, are working atmaximum capacity or at a utilization rate that satisfies utilizationthreshold, such that the indexing node 404 should not be used to processadditional data for a time. As another example, the resource catalog 420can include information relating to an availability or responsiveness ofan indexing node 404, an amount of processing resources in use by anindexing node 404, or an amount of memory used by an indexing node 404.

In some cases, the information relating to the indexing nodes 404includes one or more status identifiers associated with one or more ofthe indexing nodes 404 in the indexing system 212. For example, in somecases, a status identifier associated with one or more of the indexingnodes 404 can include information relating to an availability of anindexing node. For example, the information relating to the indexingnodes 404 can include an indication of whether an indexing node 404 isavailable or unavailable. In some instances, as described herein, thisindication of availability can be based on a status update (or absenceof a status update) from the indexing node 404. In some instances, anindexing node 404 is considered available if it is instantiated in theindexing system 212, provides periodic status updates to the resourcemonitor 418, and/or is responsive communications from the resourcemonitor 418. In some cases, an indexing node 404 is considered availableif one or more metrics associated with the indexing node 404 satisfies ametrics threshold. For example, an indexing node 404 can consideredavailable if a utilization rate of the indexing node 404 satisfies autilization rate threshold. As another example, an indexing node 404 canconsidered available if an amount of memory used by or available to theindexing node 404 satisfies a memory threshold (non-limiting example:available memory>10% of total memory, etc.). As another example, anindexing node 404 can be considered available if an amount of availableprocessing resources of the indexing node 404 satisfies a processingresources threshold (non-limiting example: CPU usage<90% of capacity,etc.). Similarly, in some cases, an indexing node 404 can be consideredunavailable if one or more, or some or all, metrics associated with theindexing node 404 do not satisfy a metrics threshold.

In some cases, the information relating to the indexing nodes 404includes information relating to a network architecture associated withone or more of the indexing nodes 404 in the indexing system 212. Forexample, information relating to a network architecture can include anindication of when, where, or on what host machine, an indexing node isinstantiated. As another example, information relating to a networkarchitecture can include an indication of a location of an indexing node404, for example with reference to other indexing nodes 404. As anotherexample, information relating to a network architecture can include anindication of computing resources shared with other indexing nodes 404,such as data stores, processors, I/O, etc.

In some cases, the information relating to the indexing nodes 404includes information relating to one or more indexing node assignments.As described herein, an indexing node assignment can include anindication of a mapping between a particular indexing node 404 and anidentifier (for example, a tenant identifier, a partition manageridentifier, etc.) or between a particular node and a data recordreceived from the intake system 210. In this way, an indexing nodeassignment can be utilized to determine to which indexing node 404 apartition manager 408 should send data to process. For example, anindexing node assignment can indicate that a particular partitionmanager 408 should send its data to one or more particular indexingnodes 404. As another example, an indexing node assignment can indicatethat some or all data associated with a particular identifier (forexample, data associated with a particular tenant identifier) should beforwarded to one or more a particular indexing node 404 for processing.In some cases, a processing device associated with the resource catalog420 can determine an indexing node assignment and can store the indexingnode assignment in the resource catalog 420. In some cases, an indexingnode assignment, is not stored in the resource catalog 420. For example,each time the resource monitor 418 receives a request for an indexingnode assignment from a partition manager 408, the resource monitor 418can use information stored in the resource catalog 420 to determine theindexing node assignment, but the indexing node assignment may not bestored in the resource catalog 420. In this way, the indexing nodeassignments can be altered, for example if necessary based oninformation relating to the indexing nodes 404.

3.3.6 Resource Monitor

The resource monitor 418 can monitor indexing nodes 404, populate andmaintain the resource catalog 420 with relevant information, receiverequests for indexing node 404 availability or assignments, identifyindexing nodes 404 that are available to process data, and/orcommunicate information relating to available indexing nodes (orindexing node assignments). The resource monitor 418 can be implementedas a distinct computing device, virtual machine, container, container ofa pod, or a process or thread associated with a container.

The resource monitor 418 maintains the resource catalog 420. Forexample, the resource monitor 418 can communicate with or monitor theindexing nodes 404 to determine or identify information relating to theindexing nodes 404, such as indexing node identifiers, metrics, statusidentifiers, network architecture data, or indexing node assignments,that it can used to build or update the resource catalog 420. Theresource monitor 418 can populate the resource catalog 420 and/or updateit over time. For example, as information relating to the indexing nodes404 changes for the different indexing nodes 404, the resource monitor418 can update the resource catalog 420. In this way, the resourcecatalog 420 can retain an up-to-date database of indexing nodeinformation.

In some cases, the resource monitor 418 can maintain the resourcecatalog 420 by pinging the indexing nodes 404 for information orpassively receiving it based on the indexing nodes 404 independentlyreporting the information. For instance, the resource monitor 418 canping or receive information from the indexing nodes 404 at predeterminedintervals of time, such as every 1, 2, 5, 10, 30, or 60 seconds. Inaddition or alternatively, the indexing nodes 404 can be configured toautomatically send their data to the resource monitor 418 and/or theresource monitor 418 can ping a particular indexing node 404 after thepassage of a predetermined period of time (for example, 1, 2, 5, 10, 30,or 60 seconds) since the resource monitor 418 requested and/or receiveddata from that particular indexing node 404. In some cases, the resourcemonitor 418 can determine that an indexing node 404 is unavailable orfailing based on the communications or absence of communications fromthe indexing node 404, and can update the resource catalog 420accordingly.

The resource monitor 418 can identify available indexing nodes 404 andprovide indexing node assignments for processing data records. In someembodiments, the resource monitor 418 can respond to requests frompartition managers 408 for an indexing node to process one or more datarecords. As described herein, a partition manager 408 can receive datarecords from the ingestion buffer 310. For each data record (or for agroup of data records), the partition manager 408 can request theresource monitor 418 for an indexing node 404 to process a particulardata record or group of data records, such as data records from the sametenant. In some cases, the resource monitor can respond with an indexingnode identifier that identifies an available indexing node for thepartition manager 408 to send the data. In certain cases, the requestcan include a data identifier associated with the data to be processed,such as a tenant identifier. The resource monitor 418 can use the dataidentifier to determine which indexing node 404 is to process the data.

The resource monitor 418 can identify available indexing nodes using oneor more of various techniques. For example, in some cases, the resourcemonitor 418 identifies an available indexing node 404 based on data inthe resource catalog 420 such as, but not limited to, indexing nodeidentifiers, metrics, status identifiers, network architecture data, orindexing node assignments. In some cases, the resource monitor 418 candetermine that an indexing node 404 is available if data relating tothat indexing node satisfies a certain threshold. For example, theresource monitor 418 can determine that an indexing node 404 isavailable if it is instantiated in the indexing system 212, has recentlyreported data to the resource monitor 418, and/or is responsive tocommunications from the resource monitor 418.

In some cases, the resource monitor 418 can determine that an indexingnode 404 is available if one or more metrics associated with theindexing node 404 satisfies a metrics threshold. For example, theresource monitor 418 can determine that an indexing node 404 isavailable if a utilization rate of the indexing node 404 satisfies autilization rate threshold and/or if an amount of available memoryavailable to the indexing node 404 satisfies a memory threshold. Asanother example, the resource monitor 418 can determine that an indexingnode 404 is available if an amount of available processing resources ofthe indexing node 404 satisfies a processing resources threshold.Similarly, in some cases, an indexing node 404 can be consideredunavailable if one or more, or some or all, metrics associated with theindexing node 404 do not satisfy a metrics threshold.

In addition to identifying available indexing nodes 404, the resourcemonitor 418 can identify to which indexing node a particular data recordor group of records is to be sent. The resource monitor 418 can map orassign a data record to an indexing node to using one or moretechniques. In some embodiments, the resource monitor 418 can use anindexing node mapping policy to determine how to map, link, or associatean indexing node to a data record.

In some embodiments, the indexing node mapping policy can indicate thatdata records are to be assigned to indexing nodes randomly, based on anorder (e.g., sequentially assign indexing nodes 404 as requests arereceived), based on previous assignments, based on a data identifierassociated with the data records, etc.

As described herein, each data record transmitted by the ingestionbuffer 310 can be associated with a data identifier that, for example,relates to a particular data source 202, tenant, index, or sourcetype.In some cases, the resource monitor 418 can use the data identifierassociated with the data record to assign the data record to aparticular indexing node 404. In the event, a partition manager 408receives other data records associated with the same data identifier, itcan communicate the other data records to the same indexing node 404 forprocessing.

In some embodiments, the resource catalog 420 can store an indexing nodeassignment listing that associates indexing nodes 404 with dataidentifiers. In some such embodiments, the indexing node mapping policycan indicate that the resource monitor 418 is to use the listing todetermine whether a particular data identifier is associated with anindexing node 404. As a non-limiting example, if the resource monitor418 receives a request from a partition manager 408 to map a data recordassociated with a data identifier to an indexing node, the resourcemonitor 418 can use the indexing node assignment listing to identify theindexing node that is to process the data record. In some suchembodiments, the indexing node assignment listing can include multipleindexing nodes 404 associated with the data identifier and the resourcemonitor 418 can assign one of the indexing nodes 404 based on itsdetermined availability (non-limiting example: metrics relating to thatindexing node 404 satisfy one or more metrics thresholds). Accordingly,based on the data identifier and the determined availability of theindexing nodes, the resource monitor 418 can assign an indexing node 404to process the data record.

As described herein, in some cases, partition managers 408 can alsostore an indexing node assignment listing. In certain embodiments, theindexing node assignment listing stored by the partition managers 408can be the same as the indexing node assignment listing stored by theresource catalog 420. For example, the resource monitor 418 can generatethe indexing node assignment listing for the resource catalog 420 anddistribute the indexing node assignment listing to the instantiatedpartition managers 408. In some embodiments, the indexing nodeassignment listing stored by the partition managers 408 can be differentfrom the indexing node assignment listing stored by the resource catalog420. For example, the indexing node assignment listing stored by theresource catalog 420 can correspond to indexing node assignments acrosssome or all partition managers 408, whereas the indexing node assignmentlisting for a particular partition manager 408 may only include theindexing node assignments for data that it (or a group of relatedpartition managers 408) has processed.

As another example, in some embodiments, the indexing node mappingpolicy can indicate that the resource monitor 418 is to use a hashfunction or other function to map a data identifier (or data record) toa particular indexing node 404. In certain embodiments, the resourcemonitor 418 can hash the data identifier, and use the output of the hashto identify an available indexing node 404. For example, if there arethree indexing nodes, the resource monitor 418 can assign the datarecord to one of the indexing nodes 404 based on a hash of a tenantidentifier of the data. In this way, other data associated with the sametenant can be assigned to the same indexing nodes 404.

In certain embodiments, the indexing node mapping policy can indicatethat the resource monitor 418 is to use a consistent hash to map thedata identifier to an indexing node 404. As part of using a consistenthash, the resource monitor 418 can perform a hash on identifiers of theindexing nodes and map the hash values to a ring. The resource monitor418 can then perform a hash on the data identifier (non-limitingexample: tenant identifier). Based on the location of the resulting hashvalue on the ring, the resource monitor 418 can assign the data recordto an indexing node. In certain cases, the resource monitor 418 canassign the data record based on the location of the hashed dataidentifier to the location of the hashed indexing node identifiers onthe ring. For example, the resource monitor 418 can map the dataidentifier to the indexing node 404 whose hashed node identifier isclosest to or next in line (in a particular direction) on the hash ringto the hashed data identifier. In some cases, the resource monitor 418maps the data identifier to multiple indexing nodes 404, for example, byselecting two or more indexing nodes that have a position on the hashring that is closest, or next in line, to the hash value of the dataidentifier when fitted on the hash ring. In some cases, the consistenthash function can be configured such that even with a different numberof indexing nodes 404 being instantiated in the indexing system 212, theoutput of the hashing will consistently identify the same indexing node404, or have an increased probability of identifying the same indexingnode 404.

In some instances, the indexing node mapping policy can indicate thatthe resource monitor 418 is to map a data identifier to an indexing node404 randomly, or in a simple sequence (e.g., a first indexing nodes 404is mapped to a first data identifier, a second indexing node 404 ismapped to a second data identifier, etc.). In other instances, asdiscussed, the indexing node mapping policy can indicate that theresource monitor 418 is to map data identifiers to indexing nodes 404based on previous mappings.

In certain embodiments, according to the indexing node mapping policy,indexing nodes 404 may be mapped to data identifiers based on overlapsof computing resources of the indexing nodes 404. For example, if apartition manager 408 is instantiated on the same host system as anindexing node 404, the resource monitor 418 can assign the data from thepartition manager to the indexing node 404.

Accordingly, it will be understood that the resource monitor 418 can mapany indexing node 404 to any data identifier, and that the indexing nodemapping policy can indicate that the resource monitor 418 is to use anyone or any combination of the above-described mechanisms to map dataidentifiers (or data records) to indexing nodes 404.

Based on the determined mapping of a data identifier to an indexing node404, the resource monitor 418 can respond to a partition manager 408.The response can include an identifier for the assigned indexing nodethat is to process the data record or the data records associated with aparticular data identifier. In certain embodiments, the response caninclude instructions that the identified indexing node 404 is to be usedfor a particular length of time, such as one minute, five minutes, etc.

3.4. Query System

FIG. 5 is a block diagram illustrating an embodiment of a query system214 of the data intake and query system 108. The query system 214 canreceive, process, and execute queries from multiple client devices 204,which may be associated with different tenants, users, etc. Similarly,the query system 214 can execute the queries on data from the intakesystem 210, indexing system 212, common storage 216, acceleration datastore 222, or other system. Moreover, the query system 214 can includevarious components that enable it to provide a stateless or state-freesearch service, or search service that is able to rapidly recoverwithout data loss if one or more components of the query system 214become unresponsive or unavailable.

In the illustrated embodiment, the query system 214 includes one or morequery system managers 502 (collectively or individually referred to asquery system manager 502), one or more search heads 504 (collectively orindividually referred to as search head 504 or search heads 504), one ormore search nodes 506 (collectively or individually referred to assearch node 506 or search nodes 506), a resource monitor 508, and aresource catalog 510. However, it will be understood that the querysystem 214 can include fewer or more components as desired. For example,in some embodiments, the common storage 216, data store catalog 220, orquery acceleration data store 222 can form part of the query system 214,etc.

As described herein, each of the components of the query system 214 canbe implemented using one or more computing devices as distinct computingdevices or as one or more container instances or virtual machines acrossone or more computing devices. For example, in some embodiments, thequery system manager 502, search heads 504, and search nodes 506 can beimplemented as distinct computing devices with separate hardware,memory, and processors. In certain embodiments, the query system manager502, search heads 504, and search nodes 506 can be implemented on thesame or across different computing devices as distinct containerinstances, with each container having access to a subset of theresources of a host computing device (e.g., a subset of the memory orprocessing time of the processors of the host computing device), butsharing a similar operating system. In some cases, the components can beimplemented as distinct virtual machines across one or more computingdevices, where each virtual machine can have its own unshared operatingsystem but shares the underlying hardware with other virtual machines onthe same host computing device.

3.4.1. Query System Manager

As mentioned, the query system manager 502 can monitor and manage thesearch heads 504 and search nodes 506, and can be implemented as adistinct computing device, virtual machine, container, container of apod, or a process or thread associated with a container. For example,the query system manager 502 can determine which search head 504 is tohandle an incoming query or determine whether to generate an additionalsearch node 506 based on the number of queries received by the querysystem 214 or based on another search node 506 becoming unavailable orunresponsive. Similarly, the query system manager 502 can determine thatadditional search heads 504 should be generated to handle an influx ofqueries or that some search heads 504 can be de-allocated or terminatedbased on a reduction in the number of queries received.

In certain embodiments, the query system 214 can include one querysystem manager 502 to manage all search heads 504 and search nodes 506of the query system 214. In some embodiments, the query system 214 caninclude multiple query system managers 502. For example, a query systemmanager 502 can be instantiated for each computing device (or group ofcomputing devices) configured as a host computing device for multiplesearch heads 504 and/or search nodes 506.

Moreover, the query system manager 502 can handle resource management,creation, assignment, or destruction of search heads 504 and/or searchnodes 506, high availability, load balancing, applicationupgrades/rollbacks, logging and monitoring, storage, networking, servicediscovery, and performance and scalability, and otherwise handlecontainerization management of the containers of the query system 214.In certain embodiments, the query system manager 502 can be implementedusing Kubernetes or Swarm. For example, in certain embodiments, thequery system manager 502 may be part of a sidecar or sidecar containerthat allows communication between various search nodes 506, varioussearch heads 504, and/or combinations thereof.

In some cases, the query system manager 502 can monitor the availableresources of a host computing device and/or request additional resourcesin a shared resource environment, based on workload of the search heads504 and/or search nodes 506 or create, destroy, or reassign search heads504 and/or search nodes 506 based on workload. Further, the query systemmanager 502 system can assign search heads 504 to handle incomingqueries and/or assign search nodes 506 to handle query processing basedon workload, system resources, etc. In some embodiments, the querysystem manager 502 system can assign search heads 504 to handle incomingqueries based on a search head mapping policy, as described herein.

3.4.2. Search Head

As described herein, the search heads 504 can manage the execution ofqueries received by the query system 214. For example, the search heads504 can parse the queries to identify the set of data to be processedand the manner of processing the set of data, identify the location ofthe data (non-limiting examples: intake system 210, common storage 216,acceleration data store 222, etc.), identify tasks to be performed bythe search head and tasks to be performed by the search nodes 506,distribute the query (or sub-queries corresponding to the query) to thesearch nodes 506, apply extraction rules to the set of data to beprocessed, aggregate search results from the search nodes 506, store thesearch results in the query acceleration data store 222, return searchresults to the client device 204, etc.

As described herein, the search heads 504 can be implemented on separatecomputing devices or as containers or virtual machines in avirtualization environment. In some embodiments, the search heads 504may be implemented using multiple-related containers. In certainembodiments, such as in a Kubernetes deployment, each search head 504can be implemented as a separate container or pod. For example, one ormore of the components of the search head 504 can be implemented asdifferent containers of a single pod, e.g., on a containerizationplatform, such as Docker, the one or more components of the indexingnode can be implemented as different Docker containers managed bysynchronization platforms such as Kubernetes or Swarm. Accordingly,reference to a containerized search head 504 can refer to the searchhead 504 as being a single container or as one or more components of thesearch head 504 being implemented as different, related containers.

In the illustrated embodiment, the search heads 504 includes a searchmaster 512 and one or more search managers 514 to carry out its variousfunctions. However, it will be understood that the search heads 504 caninclude fewer or more components as desired. For example, the searchhead 504 can include multiple search masters 512.

In some embodiments, the search heads 504 can provide information to theresource monitor 508 in order to update the information stored in theresource catalog 510, which may include information such as anidentifier for each search head 504, as well as availabilityinformation. For example, the information in the resource catalog 510may identify and indicate search heads 504 that are instantiated andavailable (e.g., have sufficient bandwidth to process/execute a query),instantiated but are unavailable or unresponsive, and so forth. Theupdated information may indicate the amount of processing resourcescurrently in use by each search head 504, the current utilization rateof each search head 504, the amount of memory currently used by eachsearch head 504, the number of queries being processed/executed by asearch head 504, etc. It should be noted that the information can beprovided ad hoc or on a periodic basis. In some such embodiments, theinformation considered “current” (e.g., the amount of processingresources currently in use) may refer to the most-recent updatedinformation (e.g., the information last provided), the accuracy of whichmay depend on the how recently the information as reported. The searchheads 504 may provide information upon request (e.g., in response to aping) or may provide information based on a set schedule (e.g., sendinformation to the resource monitor 508 on a periodic basis).

3.4.2.1. Search Master

The search master 512 can manage the execution of the various queriesassigned to the search head 504, and can be implemented as a distinctcomputing device, virtual machine, container, container of a pod, or aprocess or thread associated with a container. For example, in certainembodiments, as the search head 504 is assigned a query, the searchmaster 512 can generate one or more search manager(s) 514 to manage thequery. In some cases, the search master 512 generates a separate searchmanager 514 for each query that is received by the search head 504. Inaddition, once a query is completed, the search master 512 can handlethe termination of the corresponding search manager 514.

In certain embodiments, the search master 512 can track and store thequeries assigned to the different search managers 514. Accordingly, if asearch manager 514 becomes unavailable or unresponsive, the searchmaster 512 can generate a new search manager 514 and assign the query tothe new search manager 514. In this way, the search head 504 canincrease the resiliency of the query system 214, reduce delay caused byan unresponsive component, and can aid in providing a statelesssearching service.

In some embodiments, the search master 512 is implemented as abackground process, or daemon, on the search head 504 and the searchmanager(s) 514 are implemented as threads, copies, or forks of thebackground process. In some cases, a search master 512 can copy itself,or fork, to create a search manager 514 or cause a template process tocopy itself, or fork, to create each new search manager 514, etc., inorder to support efficient multithreaded implementations

3.4.2.2. Search Manager

As mentioned, the search managers 514 can manage the processing andexecution of the queries assigned to the search head 504, and can beimplemented as a distinct computing device, virtual machine, container,container of a pod, or a process or thread associated with a container.In some embodiments, one search manager 514 manages the processing andexecution of one query at a time. In such embodiments, if the searchhead 504 is processing one hundred queries, the search master 512 cangenerate one hundred search managers 514 to manage the one hundredqueries. Upon completing an assigned query, the search manager 514 canawait assignment to a new query or be terminated.

As part of managing the processing and execution of a query, and asdescribed herein, a search manager 514 can parse the query to identifythe set of data and the manner in which the set of data is to beprocessed (e.g., the transformations that are to be applied to the setof data), determine tasks to be performed by the search manager 514 andtasks to be performed by the search nodes 506, identify search nodes 506that are available to execute the query, map search nodes 506 to the setof data that is to be processed, instruct the search nodes 506 toexecute the query and return results, aggregate and/or transform thesearch results from the various search nodes 506, and provide the searchresults to a user and/or to the query acceleration data store 222.

In some cases, to aid in identifying the set of data to be processed,the search manager 514 can consult the data store catalog 220 (depictedin FIG. 2). As described herein, the data store catalog 220 can includeinformation regarding the data stored in common storage 216. In somecases, the data store catalog 220 can include bucket identifiers, a timerange, and a location of the buckets in common storage 216. In addition,the data store catalog 220 can include a tenant identifier and partitionidentifier for the buckets. This information can be used to identifybuckets that include data that satisfies at least a portion of thequery.

As a non-limiting example, consider a search manager 514 that has parseda query to identify the following filter criteria that is used toidentify the data to be processed: time range: past hour, partition:_sales, tenant: ABC, Inc., keyword: Error. Using the received filtercriteria, the search manager 514 can consult the data store catalog 220.Specifically, the search manager 514 can use the data store catalog 220to identify buckets associated with the “_sales” partition and thetenant “ABC, Inc.” and that include data from the “past hour.” In somecases, the search manager 514 can obtain bucket identifiers and locationinformation from the data store catalog 220 for the buckets storing datathat satisfies at least the aforementioned filter criteria. In certainembodiments, if the data store catalog 220 includes keyword pairs, itcan use the keyword “Error” to identify buckets that have at least oneevent that include the keyword “Error.”

Accordingly, the data store catalog 220 can be used to identify relevantbuckets and reduce the number of buckets that are to be searched by thesearch nodes 506. In this way, the data store catalog 220 can decreasethe query response time of the data intake and query system 108. Inaddition, in some embodiments, using the bucket identifiers and/or thelocation information, the search manager 514 can identify and/or assignone or more search nodes 506 to search the corresponding buckets.

In some embodiments, the use of the data store catalog 220 to identifybuckets for searching can contribute to the statelessness of the querysystem 214 and search head 504. For example, if a search head 504 orsearch manager 514 becomes unresponsive or unavailable, the query systemmanager 502 or search master 512, as the case may be, can spin up orassign an additional resource (e.g., new search head 504 or new searchmanager 514) to execute the query. As the bucket information ispersistently stored in the data store catalog 220, data lost due to theunavailability or unresponsiveness of a component of the query system214 can be recovered by using the bucket information in the data storecatalog 220.

In certain embodiments, to identify search nodes 506 that are availableto execute the query, the search manager 514 can consult the resourcecatalog 510. As described herein, the resource catalog 510 can includeinformation regarding the search nodes 506 (and search heads 504). Insome cases, the resource catalog 510 can include an identifier for eachsearch node 506, as well as utilization and availability information.For example, the resource catalog 510 can identify search nodes 506 thatare instantiated but are unavailable or unresponsive. In addition, theresource catalog 510 can identify the utilization rate of the searchnodes 506. For example, the resource catalog 510 can identify searchnodes 506 that are working at maximum capacity or at a utilization ratethat satisfies utilization threshold, such that the search node 506should not be used to execute additional queries for a time.

In addition, the resource catalog 510 can include architecturalinformation about the search nodes 506. For example, the resourcecatalog 510 can identify search nodes 506 that share a data store and/orare located on the same computing device, or on computing devices thatare co-located. In some embodiments, the search manager 514 can consultthe resource monitor 508, which can retrieve the relevant informationfrom the resource catalog 510 and provide it to the search manager 514.

Accordingly, in some embodiments, based on the receipt of a query, asearch manager 514 can consult the resource catalog 510 (or the resourcemonitor 508) for search nodes 506 that are available to execute thereceived query. Based on the consultation of the resource catalog 510(or the resource monitor 508), the search manager 514 can determinewhich search nodes 506 to assign to execute the query.

In some embodiments, the query system 214 (non-limiting examples: searchmanager 514 and/or resource monitor 508) can use a search node mappingpolicy to identify and/or assign search nodes 506 for a particular queryor to access particular buckets as part of the query. In certainembodiments, the search node mapping policy can include sub-policies,such as a search head-node mapping policy and/or a search node-datamapping policy (described below).

Although reference is made herein to search manager 514 or resourcemonitor 508 identifying/assigning search nodes 506 for a particularquery or bucket, it will be understood that any one any combination ofthe components of the query system 214 can make the assignments and/oruse the search node mapping policy (or one of its sub-policies). Forexample, the search manager 514 can request one or more available searchnodes 506 from the resource monitor 508 and then assign or map one ormore of the available search nodes for the query, and/or assign thesearch nodes 506 to process particular buckets, etc. As another example,the search manager 514 can request one or more search nodes 506 and theresource monitor 508 can identify available search nodes 506, assign ormap them to the search manager 514 for the query, inform the searchmanager 514 of the assigned search nodes 506, and/or assign the searchnodes 506 to process particular buckets, etc. As another example, theresource monitor 508 may use a one search node mapping policy (e.g.,search head-node mapping policy) to identify one or more search nodes506 for a particular query and the search manager 514 may use adifferent search node mapping policy (e.g., search node-data mappingpolicy) to determine which buckets are to be accessed by which of theassigned search nodes, etc.

As part of the query execution, the search manager 514 can instruct thesearch nodes 506 to execute the query (or sub-query) on the assignedbuckets. As described herein, the search manager 514 can generatespecific queries or sub-queries for the individual search nodes 506. Thesearch nodes 506 can use the queries to execute the query on the bucketsassigned thereto.

In some embodiments, the search manager 514 stores the sub-queries andbucket assignments for the different search nodes 506. Storing thesub-queries and bucket assignments can contribute to the statelessnessof the query system 214. For example, in the event an assigned searchnode 506 becomes unresponsive or unavailable during the query execution,the search manager 514 can re-assign the sub-query and bucketassignments of the unavailable search node 506 to one or more availablesearch nodes 506 or identify a different available search node 506 fromthe resource catalog 510 to execute the sub-query. In certainembodiments, the query system manager 502 can generate an additionalsearch node 506 to execute the sub-query of the unavailable search node506. Accordingly, the query system 214 can quickly recover from anunavailable or unresponsive component without data loss and whilereducing or minimizing delay.

During the query execution, the search manager 514 can monitor thestatus of the assigned search nodes 506. In some cases, the searchmanager 514 can ping or set up a communication link between it and thesearch nodes 506 assigned to execute the query. As mentioned, the searchmanager 514 can store the mapping of the buckets to the search nodes506. Accordingly, in the event a particular search node 506 becomesunavailable or is unresponsive, the search manager 514 can assign adifferent search node 506 to complete the execution of the query for thebuckets assigned to the unresponsive search node 506.

In some cases, as part of the status updates to the search manager 514,the search nodes 506 can provide the search manager with partial resultsand information regarding the buckets that have been searched. Inresponse, the search manager 514 can store the partial results andbucket information in persistent storage. Accordingly, if a search node506 partially executes the query and becomes unresponsive orunavailable, the search manager 514 can assign a different search node506 to complete the execution, as described above. For example, thesearch manager 514 can assign a search node 506 to execute the query onthe buckets that were not searched by the unavailable search node 506.In this way, the search manager 514 can more quickly recover from anunavailable or unresponsive search node 506 without data loss and whilereducing or minimizing delay.

As the search manager 514 receives query results from the differentsearch nodes 506, it can process the data. In some cases, the searchmanager 514 processes the partial results as it receives them. Forexample, if the query includes a count, the search manager 514 canincrement the count as it receives the results from the different searchnodes 506. In certain cases, the search manager 514 waits for thecomplete results from the search nodes before processing them. Forexample, if the query includes a command that operates on a result set,or a partial result set, e.g., a stats command (e.g., a command thatcalculates one or more aggregate statistics over the results set, e.g.,average, count, or standard deviation, as examples), the search manager514 can wait for the results from all the search nodes 506 beforeexecuting the stats command.

As the search manager 514 processes the results or completes processingthe results, it can store the results in the query acceleration datastore 222 or communicate the results to a client device 204. Asdescribed herein, results stored in the query acceleration data store222 can be combined with other results over time. For example, if thequery system 214 receives an open-ended query (e.g., no set end time),the search manager 515 can store the query results over time in thequery acceleration data store 222. Query results in the queryacceleration data store 222 can be updated as additional query resultsare obtained. In this manner, if an open-ended query is run at time B,query results may be stored from initial time A to time B. If the sameopen-ended query is run at time C, then the query results from the prioropen-ended query can be obtained from the query acceleration data store222 (which gives the results from time A to time B), and the query canbe run from time B to time C and combined with the prior results, ratherthan running the entire query from time A to time C. In this manner, thecomputational efficiency of ongoing search queries can be improved.

3.4.2.2.1. Search Head-Node Mapping Policy

As described, the search node mapping policy can include one or moresub-policies. In certain embodiments, the search node mapping policy caninclude search head-node mapping policy, which can be used by the searchmanager 514 and/or resource monitor 508 to identify the search nodes 506to use for a query or to assign search nodes 506 to a search head 504,to a search manager 514, or to a data identifier associated with thequery. In some embodiments, the search head-node mapping policy canindicate that search nodes 506 are to be assigned for a particular queryrandomly, based on an order (e.g., sequentially assign search nodes 506as queries are received), based on availability, based on previousassignments, based on a data identifier associated with the query, etc.

As described herein, each query received by the query system 214 can beassociated with a data identifier that, for example, relates to aparticular tenant, data source 202, index, or sourcetype, etc. In somecases, the resource monitor 508 can use the data identifier associatedwith a particular query to assign the search nodes 506 for theparticular query.

In some embodiments, the resource catalog 510 can store a search nodeassignment listing that associates search nodes 506 with dataidentifiers. In some such embodiments, the search head-node mappingpolicy can indicate that the resource monitor 508 is to use the listingto determine whether a particular data identifier is associated with oneor more search node(s) 506. As a non-limiting example, if the resourcemonitor 508 receives a request from a search manager 514 to map one ormore search nodes 506 to a query associated with a data identifier, theresource monitor 508 can use the search node assignment listing toidentify the search node(s) 506 that are to execute the query. In somesuch embodiments, the search node assignment listing can includemultiple search nodes 506 associated with the data identifier and theresource monitor 508 can assign multiple search nodes 506 based on theirdetermined availability (non-limiting example: metrics relating to thatsearch node 506 satisfy one or more metrics thresholds). Accordingly,based on the data identifier and the determined availability of thesearch nodes 506, the resource monitor 508 can assign one or more searchnodes 506 to execute the query.

In some cases, search heads 504 can store a search node assignmentlisting. In certain embodiments, the search node assignment listingstored by the search heads 504 can be the same as the search nodeassignment listing stored by the resource catalog 510. For example, theresource monitor 508 can generate the search node assignment listing forthe resource catalog 510 and distribute the search node assignmentlisting to the instantiated search heads 504 and/or search managers 514.In some embodiments, the search node assignment listing stored by thesearch heads 504 can be different from the search node assignmentlisting stored by the resource catalog 510. For example, the search nodeassignment listing stored by the resource catalog 510 can correspond tosearch node assignments across some or all search heads 504 or searchmanagers 514, whereas the search node assignment listing for aparticular search head 504 or search manager 514 may only include thesearch node assignments for queries that it (or a group of relatedsearch heads 504) has processed.

As another example, in some embodiments, the search head-node mappingpolicy can indicate that the resource monitor 508 is to use a hashfunction or other function to map one or more particular search nodes506 to a data identifier (or query) or search manager 514. In certainembodiments, the resource monitor 508 can hash the data identifier, anduse the output of the hash to identify available search node(s) 506. Forexample, if there are ten search nodes 506 and three are to be used toexecute a query associated with a particular tenant, the resourcemonitor 508 can assign three search nodes 506 to the search manager 514that is managing the query based on a hash of a tenant identifier of thetenant. In this way, other queries associated with the same tenant canbe assigned to the same search nodes 506, or the query system 214 canincrease the likelihood that other queries associated with the sametenant can be assigned to the same search nodes 506.

In certain embodiments, the search head-node mapping policy can indicatethat the resource monitor 508 is to use a consistent hash to map thesearch node(s) 506 to the search manager 514 for the query. As part ofusing a consistent hash, the resource monitor 508 can perform a hash onidentifiers of the search nodes 506 and map the hash values to a hashring. The resource monitor 508 can then perform a hash on the dataidentifier associated with the query (non-limiting example: tenantidentifier of the tenant whose data is to be queried). Based on thelocation of the resulting hash value on the hash ring, the resourcemonitor 508 can assign one or more search nodes 506 for the query. Incertain cases, the resource monitor 508 can assign one or more searchnodes 506 for the query based on the location of the hashed dataidentifier to the location of the hashed search node identifiers on thehash ring. For example, if three search nodes 506 are to be used for thequery, the resource monitor 508 can map the data identifier to the threesearch nodes 506 whose hashed node identifier is closest to or next inline (in a particular direction) on the hash ring to the hashed dataidentifier. In some cases, the resource monitor 508 maps the dataidentifier to multiple search nodes 506, for example, by selecting twoor more search nodes 506 that have a position on the hash ring that isclosest, or next in line, to the hash value of the data identifier whenfitted on the hash ring. In some cases, the consistent hash function canbe configured such that even with a different number of search nodes 506being instantiated in the query system 214, the output of the hashingwill consistently identify the same search node(s) 506, or have anincreased probability of identifying the same search node(s) 506 forqueries from the same tenants.

In some instances, the search head-node mapping policy can indicate thatthe resource monitor 508 is to map search node 506 for a query randomly,or in a simple sequence (e.g., a first search node(s) 506 is mapped to afirst query, a second search node 506 is mapped to a second query,etc.). In other instances, as discussed, the search head-node mappingpolicy can indicate that the resource monitor 508 is to map search nodes506 to queries/data identifiers/search manager 514 based on previousmappings.

In certain embodiments, according to the search head-node mappingpolicy, search nodes 506 may be mapped to queries/dataidentifiers/search managers 514 based on overlaps of computing resourcesof the search nodes 506. For example, if a search manager 514 isinstantiated on the same host system as a search node 506, the resourcemonitor 508 can assign the search node 506 to the query that the searchmanager 514 is managing.

Accordingly, it will be understood that the resource monitor 508 can mapany search node 506 to any query/data identifier/search manager 514, andthat the search head-node mapping policy can indicate that the resourcemonitor 508 is to use any one or any combination of the above-describedmechanisms to map search nodes 506 to search managers 514/queries/dataidentifiers.

Based on the determined query/data identifier/search manager 514 tosearch node(s) 506 mapping, the resource monitor 508 can respond to asearch manager 514. The response can include an identifier for theassigned search nodes 506 that are to execute the query. In certainembodiments, the response can include instructions that the identifiedsearch node(s) 506 are to be used for some or all of the queryexecution.

In some embodiments, the resource monitor 508 can use different policiesfor queries associated with different data identifiers. For example, forqueries associated with Tenant A, the resource monitor may use aconsistent hashing algorithm to assign search nodes 506. For queriesassociated with Tenant B, the resource monitor may use a pre-configuredset of search nodes 506 to execute the query. Similarly, the resourcemonitor 508 can assign different numbers of search nodes for differentqueries based on the data identifiers associated with the queries orbased on some other priority indicator. For example, the resourcemonitor 508 may dynamically assign up to twelve search nodes for queriesassociated with Tenant A based on the size of the query (e.g., amount ofdata to be processed as part of the query) and may consistently assignfour search nodes for queries associated with Tenant B regardless of thesize of the query. In some cases, the number of search nodes 506assigned can be based on a priority level associated with the dataidentifier or the query. For example, tenants or queries associated witha higher priority level can be allocated a larger number of search nodes506. In certain cases, the priority level can be based on an indicationreceived from a user, the identity of the tenant, etc.

3.4.2.2.1. Search Node-Data Mapping Policy

As described, the search node mapping policy can include a searchnode-data mapping policy, which can be used to map search nodes 506 tothe data that is to be processed. In some embodiments, the searchnode-data mapping policy can indicate how search nodes 506 are to beassigned to data (e.g., buckets) and when search nodes 506 are to beassigned to (and instructed to search) the data or buckets. Asmentioned, the search node-data mapping policy can be used alone or inconjunction with the search head-node mapping policy (non-limitingexample: the number and identity of search nodes 506 for a query areidentified based on a search head-node mapping policy and the dataaccessed by the assigned search nodes is determined based on a searchnode-data mapping policy) as part of the search node mapping policy.

In some cases, the search manager 514 can map the search nodes 506 tobuckets that include data that satisfies at least a portion of thequery. For example, in some cases, the search manager 514 can consultthe data store catalog 220 to obtain bucket identifiers of buckets thatinclude data that satisfies at least a portion of the query, e.g., as anon-limiting example, to obtain bucket identifiers of buckets thatinclude data associated with a particular time range. Based on theidentified buckets and search nodes 506, the search manager 514 candynamically assign (or map) search nodes 506 to individual bucketsaccording to a search node-data mapping policy.

In some embodiments, the search node-data mapping policy can indicatethat the search manager 514 is to assign all buckets to search nodes 506as a single operation. For example, where ten buckets are to be searchedby five search nodes 506, the search manager 514 can assign two bucketsto a first search node 506, two buckets to a second search node 506,etc. In another embodiment, the search node-data mapping policy canindicate that the search manager 514 is to assign buckets iteratively.For example, where ten buckets are to be searched by five search nodes506, the search manager 514 can initially assign five buckets (e.g., onebuckets to each search node 506), and assign additional buckets to eachsearch node 506 as the respective search nodes 506 complete theexecution on the assigned buckets.

Retrieving buckets from common storage 216 to be searched by the searchnodes 506 can cause delay or may use a relatively high amount of networkbandwidth or disk read/write bandwidth. In some cases, a local or shareddata store associated with the search nodes 506 may include a copy of abucket that was previously retrieved from common storage 216.Accordingly, to reduce delay caused by retrieving buckets from commonstorage 216, the search node-data mapping policy can indicate that thesearch manager 514 is to assign, preferably assign, or attempt to assignthe same search node 506 to search the same bucket over time. In thisway, the assigned search node 506 can keep a local copy of the bucket onits data store (or a data store shared between multiple search nodes506) and avoid the processing delays associated with obtaining thebucket from the common storage 216.

In certain embodiments, the search node-data mapping policy can indicatethat the search manager 514 is to use a consistent hash function orother function to consistently map a bucket to a particular search node506. The search manager 514 can perform the hash using the bucketidentifier obtained from the data store catalog 220, and the output ofthe hash can be used to identify the search node 506 assigned to thebucket. In some cases, the consistent hash function can be configuredsuch that even with a different number of search nodes 506 beingassigned to execute the query, the output will consistently identify thesame search node 506, or have an increased probability of identifyingthe same search node 506. For example, as described herein, the hashingfunction can include placing the hash of the search node identifiers andthe hash of the bucket identifiers on a hash ring, and assigning bucketsto the search nodes based on the proximity of the hash of the bucketidentifiers to the hash of the search node identifiers. In some

In certain embodiments where the query system 214 uses a hash ring aspart of a search head-node mapping policy and a hash ring as part of asearch node-data mapping policy, the hash rings can be different. Forexample, the first hash ring can include hash values of the indexingnode identifiers and the data identifier associated with the query andthe second hash ring can include hash values of the bucket identifiersand indexing node identifiers. In some such embodiments, the first hashring can be used to assign search nodes 506 for the query and the secondhash ring can be used to assign buckets to the search nodes 506 assignedfor the query.

In some embodiments, the query system 214 can store a mapping of searchnodes 506 to bucket identifiers. The search node-data mapping policy canindicate that the search manager 514 is to use the mapping to determinewhether a particular bucket has been assigned to a search node 506. Ifthe bucket has been assigned to a particular search node 506 and thatsearch node 506 is available, then the search manager 514 can assign thebucket to the search node 506. If the bucket has not been assigned to aparticular search node 506, the search manager 514 can use a hashfunction to identify a search node 506 for assignment. Once assigned,the search manager 514 can store the mapping for future use.

In certain cases, the search node-data mapping policy can indicate thatthe search manager 514 is to use architectural information about thesearch nodes 506 to assign buckets. For example, if the identifiedsearch node 506 is unavailable or its utilization rate satisfies athreshold utilization rate, the search manager 514 can determine whetheran available search node 506 shares a data store with the unavailablesearch node 506. If it does, the search manager 514 can assign thebucket to the available search node 506 that shares the data store withthe unavailable search node 506. In this way, the search manager 514 canreduce the likelihood that the bucket will be obtained from commonstorage 216, which can introduce additional delay to the query while thebucket is retrieved from common storage 216 to the data store shared bythe available search node 506.

In some instances, the search node-data mapping policy can indicate thatthe search manager 514 is to assign buckets to search nodes 506randomly, or in a simple sequence (e.g., a first search nodes 506 isassigned a first bucket, a second search node 506 is assigned a secondbucket, etc.). In other instances, as discussed, the search node-datamapping policy can indicate that the search manager 514 is to assignbuckets to search nodes 506 based on buckets previously assigned to asearch nodes 506, in a prior or current search. As mentioned above, insome embodiments each search node 506 may be associated with a localdata store or cache of information (e.g., in memory of the search nodes506, such as random access memory [“RAM”], disk-based cache, a datastore, or other form of storage). Each search node 506 can store copiesof one or more buckets from the common storage 216 within the localcache, such that the buckets may be more rapidly searched by searchnodes 506. The search manager 514 (or cache manager 516) can maintain orretrieve from search nodes 506 information identifying, for eachrelevant search node 506, what buckets are copied within local cache ofthe respective search nodes 506. In the event that the search manager514 determines that a search node 506 assigned to execute a search haswithin its data store or local cache a copy of an identified bucket, thesearch manager 514 can preferentially assign the search node 506 tosearch that locally-cached bucket.

In still more embodiments, according to the search node-data mappingpolicy, search nodes 506 may be assigned based on overlaps of computingresources of the search nodes 506. For example, where a containerizedsearch node 506 is to retrieve a bucket from common storage 216 (e.g.,where a local cached copy of the bucket does not exist on the searchnode 506), such retrieval may use a relatively high amount of networkbandwidth or disk read/write bandwidth. Thus, assigning a secondcontainerized search node 506 instantiated on the same host computingdevice might be expected to strain or exceed the network or diskread/write bandwidth of the host computing device. For this reason, insome embodiments, according to the search node-data mapping policy, thesearch manager 514 can assign buckets to search nodes 506 such that twocontainerized search nodes 506 on a common host computing device do notboth retrieve buckets from common storage 216 at the same time.

Further, in certain embodiments, where a data store that is sharedbetween multiple search nodes 506 includes two buckets identified forthe search, the search manager 514 can, according to the searchnode-data mapping policy, assign both such buckets to the same searchnode 506 or to two different search nodes 506 that share the data store,such that both buckets can be searched in parallel by the respectivesearch nodes 506.

The search node-data mapping policy can indicate that the search manager514 is to use any one or any combination of the above-describedmechanisms to assign buckets to search nodes 506. Furthermore, thesearch node-data mapping policy can indicate that the search manager 514is to prioritize assigning search nodes 506 to buckets based on any oneor any combination of: assigning search nodes 506 to process bucketsthat are in a local or shared data store of the search nodes 506,maximizing parallelization (e.g., assigning as many different searchnodes 506 to execute the query as are available), assigning search nodes506 to process buckets with overlapping timestamps, maximizingindividual search node 506 utilization (e.g., ensuring that each searchnode 506 is searching at least one bucket at any given time, etc.), orassigning search nodes 506 to process buckets associated with aparticular tenant, user, or other known feature of data stored withinthe bucket (e.g., buckets holding data known to be used intime-sensitive searches may be prioritized). Thus, according to thesearch node-data mapping policy, the search manager 514 can dynamicallyalter the assignment of buckets to search nodes 506 to increase theparallelization of a search, and to increase the speed and efficiencywith which the search is executed.

It will be understood that the search manager 514 can assign any searchnode 506 to search any bucket. This flexibility can decrease queryresponse time as the search manager can dynamically determine whichsearch nodes 506 are best suited or available to execute the query ondifferent buckets. Further, if one bucket is being used by multiplequeries, the search manager 515 can assign multiple search nodes 506 tosearch the bucket. In addition, in the event a search node 506 becomesunavailable or unresponsive, the search manager 514 can assign adifferent search node 506 to search the buckets assigned to theunavailable search node 506.

In some embodiments, the resource monitor 508 can use different searchnode-data mapping policies for queries associated with different dataidentifiers. For example, for queries associated with Tenant A, theresource monitor may use a consistent hashing algorithm to assignbuckets to search nodes 506. For queries associated with Tenant B, theresource monitor may iteratively assign buckets to search nodes 506 toexecute the query. Similarly, as described herein with reference to thesearch head-node mapping policy, a different number of search nodes 506can be assigned for queries based on a priority level of the queryand/or the data identifier associated with the query.

3.4.3. Search Nodes

As described herein, the search nodes 506 can be the primary queryexecution engines for the query system 214, and can be implemented asdistinct computing devices, virtual machines, containers, container of apods, or processes or threads associated with one or more containers.Accordingly, each search node 506 can include a processing device and adata store, as depicted at a high level in FIG. 5. Depending on theembodiment, the processing device and data store can be dedicated to thesearch node (e.g., embodiments where each search node is a distinctcomputing device) or can be shared with other search nodes or componentsof the data intake and query system 108 (e.g., embodiments where thesearch nodes are implemented as containers or virtual machines or wherethe shared data store is a networked data store, etc.).

In some embodiments, the search nodes 506 can obtain and search bucketsidentified by the search manager 514 that include data that satisfies atleast a portion of the query, identify the set of data within thebuckets that satisfies the query, perform one or more transformations onthe set of data, and communicate the set of data to the search manager514. Individually, a search node 506 can obtain the buckets assigned toit by the search manager 514 for a particular query, search the assignedbuckets for a subset of the set of data, perform one or moretransformation on the subset of data, and communicate partial searchresults to the search manager 514 for additional processing andcombination with the partial results from other search nodes 506.

In some cases, the buckets to be searched may be located in a local datastore of the search node 506 or a data store that is shared betweenmultiple search nodes 506. In such cases, the search nodes 506 canidentify the location of the buckets and search the buckets for the setof data that satisfies the query.

In certain cases, the buckets may be located in the common storage 216.In such cases, the search nodes 506 can search the buckets in the commonstorage 216 and/or copy the buckets from the common storage 216 to alocal or shared data store and search the locally stored copy for theset of data. As described herein, the cache manager 516 can coordinatewith the search nodes 506 to identify the location of the buckets(whether in a local or shared data store or in common storage 216)and/or obtain buckets stored in common storage 216.

Once the relevant buckets (or relevant files of the buckets) areobtained, the search nodes 506 can search their contents to identify theset of data to be processed. In some cases, upon obtaining a bucket fromthe common storage 216, a search node 306 can decompress the bucket froma compressed format, and accessing one or more files stored within thebucket. In some cases, the search node 306 references a bucket summaryor manifest to locate one or more portions (e.g., records or individualfiles) of the bucket that potentially contain information relevant tothe search.

In some cases, the search nodes 506 can use all of the files of a bucketto identify the set of data. In certain embodiments, the search nodes506 use a subset of the files of a bucket to identify the set of data.For example, in some cases, a search node 506 can use an inverted index,bloom filter, or bucket summary or manifest to identify a subset of theset of data without searching the raw machine data of the bucket. Incertain cases, the search node 506 uses the inverted index, bloomfilter, bucket summary, and raw machine data to identify the subset ofthe set of data that satisfies the query.

In some embodiments, depending on the query, the search nodes 506 canperform one or more transformations on the data from the buckets. Forexample, the search nodes 506 may perform various data transformations,scripts, and processes, e.g., a count of the set of data, etc.

As the search nodes 506 execute the query, they can provide the searchmanager 514 with search results. In some cases, a search node 506provides the search manager 514 results as they are identified by thesearch node 506, and updates the results over time. In certainembodiments, a search node 506 waits until all of its partial resultsare gathered before sending the results to the search manager 514.

In some embodiments, the search nodes 506 provide a status of the queryto the search manager 514. For example, an individual search node 506can inform the search manager 514 of which buckets it has searchedand/or provide the search manager 514 with the results from the searchedbuckets. As mentioned, the search manager 514 can track or store thestatus and the results as they are received from the search node 506. Inthe event the search node 506 becomes unresponsive or unavailable, thetracked information can be used to generate and assign a new search node506 to execute the remaining portions of the query assigned to theunavailable search node 506.

The search nodes 506 may provide information to the resource monitor 508in order to update the information stored in the resource catalog 510,which may include information such as an identifier for each search node506, as well as availability, responsiveness, and utilizationinformation. For example, the updated information in the resourcecatalog 510 may identify and indicate search nodes 506 that areinstantiated and currently available (e.g., currently not being used toexecute queries), instantiated but are currently unavailable orunresponsive, and so forth. The updated information may indicate theamount of processing resources currently in use by each search node 506,the current utilization rate of each search node 506, the amount ofmemory currently used by each search node 506, etc. The updatedinformation may also indicate a node type associated with each searchnode 506, the cache hit ratio for each search node 506, and so forth. Itshould be noted that the information can be provided on-the-fly or on aperiodic basis, and in the latter case, the information considered“current” (e.g., the amount of processing resources currently in use)may refer to the most-recent updated information (e.g., the informationlast provided), which can be accurate if updated information is providedrelatively frequently. The search nodes 506 may provide information uponrequest (e.g., in response to a ping) or may provide information basedon a set schedule (e.g., send information to the resource monitor 508 ona periodic basis).

3.4.4. Cache Manager

As mentioned, the cache manager 516 can communicate with the searchnodes 506 to obtain or identify the location of the buckets assigned tothe search nodes 506, and can be implemented as a distinct computingdevice, virtual machine, container, pod, or a process or threadassociated with a container.

In some embodiments, based on the receipt of a bucket assignment, asearch node 506 can provide the cache manager 516 with an identifier ofthe bucket that it is to search, a file associated with the bucket thatit is to search, and/or a location of the bucket. In response, the cachemanager 516 can determine whether the identified bucket or file islocated in a local or shared data store or is to be retrieved from thecommon storage 216.

As mentioned, in some cases, multiple search nodes 506 can share a datastore. Accordingly, if the cache manager 516 determines that therequested bucket is located in a local or shared data store, the cachemanager 516 can provide the search node 506 with the location of therequested bucket or file. In certain cases, if the cache manager 516determines that the requested bucket or file is not located in the localor shared data store, the cache manager 516 can request the bucket orfile from the common storage 216, and inform the search node 506 thatthe requested bucket or file is being retrieved from common storage 216.

In some cases, the cache manager 516 can request one or more filesassociated with the requested bucket prior to, or in place of,requesting all contents of the bucket from the common storage 216. Forexample, a search node 506 may request a subset of files from aparticular bucket. Based on the request and a determination that thefiles are located in common storage 216, the cache manager 516 candownload or obtain the identified files from the common storage 216.

In some cases, based on the information provided from the search node506, the cache manager 516 may be unable to uniquely identify arequested file or files within the common storage 216. Accordingly, incertain embodiments, the cache manager 516 can retrieve a bucket summaryor manifest file from the common storage 216 and provide the bucketsummary to the search node 506. In some cases, the cache manager 516 canprovide the bucket summary to the search node 506 while concurrentlyinforming the search node 506 that the requested files are not locatedin a local or shared data store and are to be retrieved from commonstorage 216.

Using the bucket summary, the search node 506 can uniquely identify thefiles to be used to execute the query. Using the unique identification,the cache manager 516 can request the files from the common storage 216.Accordingly, rather than downloading the entire contents of the bucketfrom common storage 216, the cache manager 516 can download thoseportions of the bucket that are to be used by the search node 506 toexecute the query. In this way, the cache manager 516 can decrease theamount of data sent over the network and decrease the search time.

As a non-limiting example, a search node 506 may determine that aninverted index of a bucket is to be used to execute a query. Forexample, the search node 506 may determine that all the information thatit needs to execute the query on the bucket can be found in an invertedindex associated with the bucket. Accordingly, the search node 506 canrequest the file associated with the inverted index of the bucket fromthe cache manager 516. Based on a determination that the requested fileis not located in a local or shared data store, the cache manager 516can determine that the file is located in the common storage 216.

As the bucket may have multiple inverted indexes associated with it, theinformation provided by the search node 506 may be insufficient touniquely identify the inverted index within the bucket. To address thisissue, the cache manager 516 can request a bucket summary or manifestfrom the common storage 216, and forward it to the search node 506. Thesearch node 506 can analyze the bucket summary to identify theparticular inverted index that is to be used to execute the query, andrequest the identified particular inverted index from the cache manager516 (e.g., by name and/or location). Using the bucket manifest and/orthe information received from the search node 506, the cache manager 516can obtain the identified particular inverted index from the commonstorage 216. By obtaining the bucket manifest and downloading therequested inverted index instead of all inverted indexes or files of thebucket, the cache manager 516 can reduce the amount of data communicatedover the network and reduce the search time for the query.

In some cases, when requesting a particular file, the search node 506can include a priority level for the file. For example, the files of abucket may be of different sizes and may be used more or less frequentlywhen executing queries. For example, the bucket manifest may be arelatively small file. However, if the bucket is searched, the bucketmanifest can be a relatively valuable file (and frequently used) becauseit includes a list or index of the various files of the bucket.Similarly, a bloom filter of a bucket may be a relatively small file butfrequently used as it can relatively quickly identify the contents ofthe bucket. In addition, an inverted index may be used more frequentlythan raw data of a bucket to satisfy a query.

Accordingly, to improve retention of files that are commonly used in asearch of a bucket, the search node 506 can include a priority level forthe requested file. The cache manager 516 can use the priority levelreceived from the search node 506 to determine how long to keep, or whento evict, the file from the local or shared data store. For example,files identified by the search node 506 as having a higher prioritylevel can be stored for a greater period of time than files identifiedas having a lower priority level.

Furthermore, the cache manager 516 can determine what data and how longto retain the data in the local or shared data stores of the searchnodes 506 based on a bucket caching policy. In some cases, the bucketcaching policy can rely on any one or any combination of the prioritylevel received from the search nodes 506 for a particular file, leastrecently used, most recent in time, or other policies to indicate howlong to retain files in the local or shared data store.

In some instances, according to the bucket caching policy, the cachemanager 516 or other component of the query system 214 (e.g., the searchmaster 512 or search manager 514) can instruct search nodes 506 toretrieve and locally cache copies of various buckets from the commonstorage 216, independently of processing queries. In certainembodiments, the query system 214 is configured, according to the bucketcaching policy, such that one or more buckets from the common storage216 (e.g., buckets associated with a tenant or partition of a tenant) oreach bucket from the common storage 216 is locally cached on at leastone search node 506.

In some embodiments, according to the bucket caching policy, the querysystem 214 is configured such that at least one bucket from the commonstorage 216 is locally cached on at least two search nodes 506. Cachinga bucket on at least two search nodes 506 may be beneficial, forexample, in instances where different queries both require searching thebucket (e.g., because the at least search nodes 506 may process theirrespective local copies in parallel). In still other embodiments, thequery system 214 is configured, according to the bucket caching policy,such that one or more buckets from the common storage 216 or all bucketsfrom the common storage 216 are locally cached on at least a givennumber n of search nodes 506, wherein n is defined by a replicationfactor on the system 108. For example, a replication factor of five maybe established to ensure that five copies of a bucket are locally cachedacross different search nodes 506.

In certain embodiments, the search manager 514 (or search master 512)can assign buckets to different search nodes 506 based on time. Forexample, buckets that are less than one day old can be assigned to afirst group of search nodes 506 for caching, buckets that are more thanone day but less than one week old can be assigned to a different groupof search nodes 506 for caching, and buckets that are more than one weekold can be assigned to a third group of search nodes 506 for caching. Incertain cases, the first group can be larger than the second group, andthe second group can be larger than the third group. In this way, thequery system 214 can provide better/faster results for queries searchingdata that is less than one day old, and so on, etc. It will beunderstood that the search nodes can be grouped and assigned buckets ina variety of ways. For example, search nodes 506 can be grouped based ona tenant identifier, index, etc. In this way, the query system 214 candynamically provide faster results based any one or any number offactors.

In some embodiments, when a search node 506 is added to the query system214, the cache manager 516 can, based on the bucket caching policy,instruct the search node 506 to download one or more buckets from commonstorage 216 prior to receiving a query. In certain embodiments, thecache manager 516 can instruct the search node 506 to download specificbuckets, such as most recent in time buckets, buckets associated with aparticular tenant or partition, etc. In some cases, the cache manager516 can instruct the search node 506 to download the buckets before thesearch node 506 reports to the resource monitor 508 that it is availablefor executing queries. It will be understood that other components ofthe query system 214 can implement this functionality, such as, but notlimited to the query system manager 502, resource monitor 508, searchmanager 514, or the search nodes 506 themselves.

In certain embodiments, when a search node 506 is removed from the querysystem 214 or becomes unresponsive or unavailable, the cache manager 516can identify the buckets that the removed search node 506 wasresponsible for and instruct the remaining search nodes 506 that theywill be responsible for the identified buckets. In some cases, theremaining search nodes 506 can download the identified buckets fromcommon storage 216 or retrieve them from the data store associated withthe removed search node 506.

In some cases, the cache manager 516 can change the bucket-search node506 assignments, such as when a search node 506 is removed or added. Incertain embodiments, based on a reassignment, the cache manager 516 caninform a particular search node 506 to remove buckets to which it is nolonger assigned, reduce the priority level of the buckets, etc. In thisway, the cache manager 516 can make it so the reassigned bucket will beremoved more quickly from the search node 506 than it otherwise wouldwithout the reassignment. In certain embodiments, the search node 506that receives the new for the bucket can retrieve the bucket from thenow unassigned search node 506 and/or retrieve the bucket from commonstorage 216.

3.4.5. Resource Monitor and Catalog

The resource monitor 508 can monitor search nodes and populate theresource catalog 510 with relevant information, and can be implementedas a distinct computing device, virtual machine, container, container ofa pod, or a process or thread associated with a container.

Although the resource monitor 508 and resource catalog 510 are shown asseparate components, it will be understood that they can be implementedas part of the same machine, host system, isolated executionenvironment, pod, container, virtual machine, etc. Furthermore, althoughseparate resource monitors 418, 508 and resource catalog 420 and 510 areshown for the indexing system 212 and the query system 214, it will beunderstood that the resource monitors 418, 508 and resource catalog 420and 510 can be implemented as part of the same machine, isolatedexecution environment, pod, container, etc. For example, the indexingsystem 212 and the query system 214 can interact with a resource monitorand resource catalog in a manner similar to which these systems (ortheir components) interact with the common storage 216, data storecatalog 220, metadata catalog 221, etc. Thus, the illustratedembodiments, should not be construed as limiting the resource monitors418, 508 and resource catalog 420 and 510 to a particular architectureor design.

In some cases, the resource monitor 508 can ping the search nodes 506over time to determine their availability, responsiveness, and/orutilization rate. In certain embodiments, each search node 506 caninclude a monitoring module that provides performance metrics or statusupdates about the search node 506 to the resource monitor 508. Forexample, the monitoring module can indicate the amount of processingresources in use by the search node 506, the utilization rate of thesearch node 506, the amount of memory used by the search node 506, etc.In certain embodiments, the resource monitor 508 can determine that asearch node 506 is unavailable or failing based on the data in thestatus update or absence of a state update from the monitoring module ofthe search node 506.

In certain embodiments, each search head 504 can include a monitoringmodule that provides performance metrics or status updates (e.g.,availability information) about the search node 506 to the resourcemonitor 508, along with information such as an identifier for thatsearch head 504. For example, the monitoring module can indicate thenumber of queries being processed by the search head 504, the amount ofprocessing resources in use by the search head 504, the amount of memoryused by the search head 504, and so forth. In certain embodiments, theresource monitor 508 can determine that a search head 504 is unavailableor failing based on the data in the status update or absence of a stateupdate from the monitoring module of the search node 506. Thus, theresource monitor 508 may be able to identify and indicate search heads504 that are instantiated and available (e.g., include sufficientbandwidth to process one or more additional queries), instantiated butare unavailable or unresponsive, and so forth. Using the informationobtained from the search heads 504 and search nodes 506, the resourcemonitor 508 can populate the resource catalog 510 and update it overtime.

As the availability, responsiveness, and/or utilization change for thedifferent search heads 504 and/or search nodes 506, the resource monitor508 can update the resource catalog 510. In this way, the resourcecatalog 510 can retain an up-to-date list of search heads 504 availableto handle queries and/or search nodes 506 available to execute a query.

Furthermore, as search heads 504 and/or search nodes 506 areinstantiated (or at other times), the newly-instantiated search heads504 and/or search nodes 506 can provide information to the resourcemonitor 508, which can update the resource catalog 510 with informationabout the newly-instantiated search heads 504 and/or search nodes 506,such as, but not limited to its computing resources, utilization,network architecture (identification of machine where it isinstantiated, location with reference to other search heads 504 and/orsearch nodes 506, computing resources shared with other search heads 504and/or search nodes 506, such as data stores, processors, I/O, etc.),etc.

In some embodiments, based on the receipt of a particular query or arequest from a search service or a component of the query system 214,the resource monitor 508 can identify a search head to process theparticular query. In certain embodiments, the resource monitor 508 canidentify the search head based on a search head mapping policy. Thesearch head mapping policy can indicate one or more criteria foridentifying or assigning a search head 504 for a query. In some cases,the search head mapping policy can indicate that a search head 504should be assigned based on its availability, the number of concurrentsearches that it is processing/managing, resource utilization, etc. Assuch, the query system 214 can dynamically assign search heads 504 toprocess queries. In some such cases, a search head 512 can process andmanage queries associated with different tenants. By configuring thesearch head 512 to process queries associated with different tenants,the data intake and query system 108 can improve resource utilizationand decrease the amount of resource used. For example, if a search head504 is statically assigned to a tenant, then its resources may beunavailable to other tenants or other components of the data intake andquery system 108, even if the tenant is not executing any searches. Incontrast if a search head 504 is dynamically assigned to queriesassociated with different tenants then if a particular tenant is notexecuting any searches then the search head 504 that would otherwise beunused can be used to process/manage queries associated with othertenants thereby increasing the resource utilization of the data intakeand query system 108 as a whole.

As described herein, the search manager 514 and/or resource monitor 508can use the resource catalog 510 to identify search nodes 506 availableto execute a query. In some embodiments, the search manager 214 and/orresource monitor 508 can communicate with the resource catalog 510 usingan API. In some embodiments, the search manager 514 and/or resourcemonitor 508 assign search nodes 506 to execute queries based on one ormore policies, such as a search node mapping policy, etc. Similar to thedynamic assignment of search heads 504 to queries associated withdifferent tenants or data identifiers, dynamically assigning searchnodes 506 to queries can significantly improve resource utilization anddecrease compute resources used by the data intake and query system 108.

3.5. Common Storage

Returning to FIG. 2, the common storage 216 can be used to store dataindexed by the indexing system 212, and can be implemented using one ormore data stores 218.

In some systems, the same computing devices (e.g., indexers) operateboth to ingest, index, store, and search data. The use of an indexer toboth ingest and search information may be beneficial, for example,because an indexer may have ready access to information that it hasingested, and can quickly access that information for searchingpurposes. However, use of an indexer to both ingest and searchinformation may not be desirable in all instances. As an illustrativeexample, consider an instance in which ingested data is organized intobuckets, and each indexer is responsible for maintaining buckets withina data store corresponding to the indexer. Illustratively, a set of tenindexers may maintain 100 buckets, distributed evenly across ten datastores (each of which is managed by a corresponding indexer).Information may be distributed throughout the buckets according to aload-balancing mechanism used to distribute information to the indexersduring data ingestion. In an idealized scenario, information responsiveto a query would be spread across the 100 buckets, such that eachindexer may search their corresponding ten buckets in parallel, andprovide search results to a search head. However, it is expected thatthis idealized scenario may not always occur, and that there will be atleast some instances in which information responsive to a query isunevenly distributed across data stores. As one example, consider aquery in which responsive information exists within ten buckets, all ofwhich are included in a single data store associated with a singleindexer. In such an instance, a bottleneck may be created at the singleindexer, and the effects of parallelized searching across the indexersmay be minimized. To increase the speed of operation of search queriesin such cases, it may therefore be desirable to store data indexed bythe indexing system 212 in common storage 216 that can be accessible toany one or multiple components of the indexing system 212 or the querysystem 214.

Common storage 216 may correspond to any data storage system accessibleto the indexing system 212 and the query system 214. For example, commonstorage 216 may correspond to a storage area network (SAN), networkattached storage (NAS), other network-accessible storage system (e.g., ahosted storage system, such as Amazon S3 or EBS provided by Amazon,Inc., Google Cloud Storage, Microsoft Azure Storage, etc., which mayalso be referred to as “cloud” storage), or combination thereof. Thecommon storage 216 may include, for example, hard disk drives (HDDs),solid state storage devices (SSDs), or other substantially persistent ornon-transitory media. Data stores 218 within common storage 216 maycorrespond to physical data storage devices (e.g., an individual HDD) ora logical storage device, such as a grouping of physical data storagedevices or a containerized or virtualized storage device hosted by anunderlying physical storage device. In some embodiments, the commonstorage 216 may also be referred to as a shared storage system or sharedstorage environment as the data stores 218 may store data associatedwith multiple customers, tenants, etc., or across different data intakeand query systems 108 or other systems unrelated to the data intake andquery systems 108.

The common storage 216 can be configured to provide high availability,highly resilient, low loss data storage. In some cases, to provide thehigh availability, highly resilient, low loss data storage, the commonstorage 216 can store multiple copies of the data in the same anddifferent geographic locations and across different types of data stores(e.g., solid state, hard drive, tape, etc.). Further, as data isreceived at the common storage 216 it can be automatically replicatedmultiple times according to a replication factor to different datastores across the same and/or different geographic locations.

In one embodiment, common storage 216 may be multi-tiered, with eachtier providing more rapid access to information stored in that tier. Forexample, a first tier of the common storage 216 may be physicallyco-located with the indexing system 212 or the query system 214 andprovide rapid access to information of the first tier, while a secondtier may be located in a different physical location (e.g., in a hostedor “cloud” computing environment) and provide less rapid access toinformation of the second tier.

Distribution of data between tiers may be controlled by any number ofalgorithms or mechanisms. In one embodiment, a first tier may includedata generated or including timestamps within a threshold period of time(e.g., the past seven days), while a second tier or subsequent tiersincludes data older than that time period. In another embodiment, afirst tier may include a threshold amount (e.g., n terabytes) orrecently accessed data, while a second tier stores the remaining lessrecently accessed data.

In one embodiment, data within the data stores 218 is grouped intobuckets, each of which is commonly accessible to the indexing system 212and query system 214. The size of each bucket may be selected accordingto the computational resources of the common storage 216 or the dataintake and query system 108 overall. For example, the size of eachbucket may be selected to enable an individual bucket to be relativelyquickly transmitted via a network, without introducing excessiveadditional data storage requirements due to metadata or other overheadassociated with an individual bucket. In one embodiment, each bucket is750 megabytes in size. Further, as mentioned, in some embodiments, somebuckets can be merged to create larger buckets.

As described herein, each bucket can include one or more files, such as,but not limited to, one or more compressed or uncompressed raw machinedata files, metadata files, filter files, indexes files, bucket summaryor manifest files, etc. In addition, each bucket can store eventsincluding raw machine data associated with a time stamp.

As described herein, the indexing nodes 404 can generate buckets duringindexing and communicate with common storage 216 to store the buckets.For example, data may be provided to the indexing nodes 404 from one ormore ingestion buffers of the intake system 210. The indexing nodes 404can process the information and store it as buckets in common storage216, rather than in a data store maintained by an individual indexer orindexing node. Thus, the common storage 216 can render information ofthe data intake and query system 108 commonly accessible to elements ofthe system 108. As described herein, the common storage 216 can enableparallelized searching of buckets to occur independently of theoperation of indexing system 212.

As noted above, it may be beneficial in some instances to separate dataindexing and searching. Accordingly, as described herein, the searchnodes 506 of the query system 214 can search for data stored withincommon storage 216. The search nodes 506 may therefore becommunicatively attached (e.g., via a communication network) with thecommon storage 216, and be enabled to access buckets within the commonstorage 216.

Further, as described herein, because the search nodes 506 in someinstances are not statically assigned to individual data stores 218 (andthus to buckets within such a data store 218), the buckets searched byan individual search node 506 may be selected dynamically, to increasethe parallelization with which the buckets can be searched. For example,consider an instance where information is stored within 100 buckets, anda query is received at the data intake and query system 108 forinformation within ten buckets. Unlike a scenario in which buckets arestatically assigned to an indexer, which could result in a bottleneck ifthe ten relevant buckets are associated with the same indexer, the tenbuckets holding relevant information may be dynamically distributedacross multiple search nodes 506. Thus, if ten search nodes 506 areavailable to process a query, each search node 506 may be assigned toretrieve and search within one bucket greatly increasing parallelizationwhen compared to the low-parallelization scenarios (e.g., where a singleindexer 206 is required to search all ten buckets).

Moreover, because searching occurs at the search nodes 506 rather thanat the indexing system 212, indexing resources can be allocatedindependently to searching operations. For example, search nodes 506 maybe executed by a separate processor or computing device than indexingnodes 404, enabling computing resources available to search nodes 506 toscale independently of resources available to indexing nodes 404.Additionally, the impact on data ingestion and indexing due toabove-average volumes of search query requests is reduced or eliminated,and similarly, the impact of data ingestion on search query resultgeneration time also is reduced or eliminated.

As will be appreciated in view of the above description, the use of acommon storage 216 can provide many advantages within the data intakeand query system 108. Specifically, use of a common storage 216 canenable the system 108 to decouple functionality of data indexing byindexing nodes 404 with functionality of searching by search nodes 506.Moreover, because buckets containing data are accessible by each searchnode 506, a search manager 514 can dynamically allocate search nodes 506to buckets at the time of a search in order to increase parallelization.Thus, use of a common storage 216 can substantially improve the speedand efficiency of operation of the system 108.

3.6. Data Store Catalog

The data store catalog 220 can store information about the data storedin common storage 216, and can be implemented using one or more datastores. In some embodiments, the data store catalog 220 can beimplemented as a portion of the common storage 216 and/or using similardata storage techniques (e.g., local or cloud storage, multi-tieredstorage, etc.). In another implementation, the data store catalog 22—mayutilize a database, e.g., a relational database engine, such ascommercially-provided relational database services, e.g., Amazon'sAurora. In some implementations, the data store catalog 220 may use anAPI to allow access to register buckets, and to allow query system 214to access buckets. In other implementations, data store catalog 220 maybe implemented through other means, and may be stored as part of commonstorage 216, or another type of common storage, as previously described.In various implementations, requests for buckets may include a tenantidentifier and some form of user authentication, e.g., a user accesstoken that can be authenticated by authentication service. In variousimplementations, the data store catalog 220 may store one datastructure, e.g., table, per tenant, for the buckets associated with thattenant, one data structure per partition of each tenant, etc. In otherimplementations, a single data structure, e.g., a single table, may beused for all tenants, and unique tenant IDs may be used to identifybuckets associated with the different tenants.

As described herein, the data store catalog 220 can be updated by theindexing system 212 with information about the buckets or data stored incommon storage 216. For example, the data store catalog can store anidentifier for a sets of data in common storage 216, a location of thesets of data in common storage 216, tenant or indexes associated withthe sets of data, timing information about the sets of data, etc. Inembodiments where the data in common storage 216 is stored as buckets,the data store catalog 220 can include a bucket identifier for thebuckets in common storage 216, a location of or path to the buckets incommon storage 216, a time range of the data in the bucket (e.g., rangeof time between the first-in-time event of the bucket and thelast-in-time event of the bucket), a tenant identifier identifying acustomer or computing device associated with the bucket, and/or an indexor partition associated with the bucket, etc.

In certain embodiments, the data store catalog 220 can include anindication of a location of a copy of a bucket found in one or moresearch nodes 506. For example, as buckets are copied to search nodes506, the query system 214 can update the data store catalog 220 withinformation about which search nodes 506 include a copy of the buckets.This information can be used by the query system 214 to assign searchnodes 506 to buckets as part of a query.

In certain embodiments, the data store catalog 220 can function as anindex or inverted index of the buckets stored in common storage 216. Forexample, the data store catalog 220 can provide location and otherinformation about the buckets stored in common storage 216. In someembodiments, the data store catalog 220 can provide additionalinformation about the contents of the buckets. For example, the datastore catalog 220 can provide a list of sources, sourcetypes, or hostsassociated with the data in the buckets.

In certain embodiments, the data store catalog 220 can include one ormore keywords found within the data of the buckets. In such embodiments,the data store catalog can be similar to an inverted index, exceptrather than identifying specific events associated with a particularhost, source, sourcetype, or keyword, it can identify buckets with dataassociated with the particular host, source, sourcetype, or keyword.

In some embodiments, the query system 214 (e.g., search head 504, searchmaster 512, search manager 514, etc.) can communicate with the datastore catalog 220 as part of processing and executing a query. Incertain cases, the query system 214 communicates with the data storecatalog 220 using an API. As a non-limiting example, the query system214 can provide the data store catalog 220 with at least a portion ofthe query or one or more filter criteria associated with the query. Inresponse, the data store catalog 220 can provide the query system 214with an identification of buckets that store data that satisfies atleast a portion of the query. In addition, the data store catalog 220can provide the query system 214 with an indication of the location ofthe identified buckets in common storage 216 and/or in one or more localor shared data stores of the search nodes 506.

Accordingly, using the information from the data store catalog 220, thequery system 214 can reduce (or filter) the amount of data or number ofbuckets to be searched. For example, using tenant or partitioninformation in the data store catalog 220, the query system 214 canexclude buckets associated with a tenant or a partition, respectively,that is not to be searched. Similarly, using time range information, thequery system 214 can exclude buckets that do not satisfy a time rangefrom a search. In this way, the data store catalog 220 can reduce theamount of data to be searched and decrease search times.

As mentioned, in some cases, as buckets are copied from common storage216 to search nodes 506 as part of a query, the query system 214 canupdate the data store catalog 220 with the location information of thecopy of the bucket. The query system 214 can use this information toassign search nodes 506 to buckets. For example, if the data storecatalog 220 indicates that a copy of a bucket in common storage 216 isstored in a particular search node 506, the query system 214 can assignthe particular search node to the bucket. In this way, the query system214 can reduce the likelihood that the bucket will be retrieved fromcommon storage 216. In certain embodiments, the data store catalog 220can store an indication that a bucket was recently downloaded to asearch node 506. The query system 214 for can use this information toassign search node 506 to that bucket.

3.7. Query Acceleration Data Store

With continued reference to FIG. 2, the query acceleration data store222 can be used to store query results or datasets for acceleratedaccess, and can be implemented as, a distributed in-memory databasesystem, storage subsystem, local or networked storage (e.g., cloudstorage), and so on, which can maintain (e.g., store) datasets in bothlow-latency memory (e.g., random access memory, such as volatile ornon-volatile memory) and longer-latency memory (e.g., solid statestorage, disk drives, and so on). In some embodiments, to increaseefficiency and response times, the accelerated data store 222 canmaintain particular datasets in the low-latency memory, and otherdatasets in the longer-latency memory. For example, in some embodiments,the datasets can be stored in-memory (non-limiting examples: RAM orvolatile memory) with disk spillover (non-limiting examples: hard disks,disk drive, non-volatile memory, etc.). In this way, the queryacceleration data store 222 can be used to serve interactive oriterative searches. In some cases, datasets which are determined to befrequently accessed by a user can be stored in the lower-latency memory.Similarly, datasets of less than a threshold size can be stored in thelower-latency memory.

In certain embodiments, the search manager 514 or search nodes 506 canstore query results in the query acceleration data store 222. In someembodiments, the query results can correspond to partial results fromone or more search nodes 506 or to aggregated results from all thesearch nodes 506 involved in a query or the search manager 514. In suchembodiments, the results stored in the query acceleration data store 222can be served at a later time to the search head 504, combined withadditional results obtained from a later query, transformed or furtherprocessed by the search nodes 506 or search manager 514, etc. Forexample, in some cases, such as where a query does not include atermination date, the search manager 514 can store initial results inthe acceleration data store 222 and update the initial results asadditional results are received. At any time, the initial results, oriteratively updated results can be provided to a client device 204,transformed by the search nodes 506 or search manager 514, etc.

As described herein, a user can indicate in a query that particulardatasets or results are to be stored in the query acceleration datastore 222. The query can then indicate operations to be performed on theparticular datasets. For subsequent queries directed to the particulardatasets (e.g., queries that indicate other operations for the datasetsstored in the acceleration data store 222), the search nodes 506 canobtain information directly from the query acceleration data store 222.

Additionally, since the query acceleration data store 222 can beutilized to service requests from different client devices 204, thequery acceleration data store 222 can implement access controls (e.g.,an access control list) with respect to the stored datasets. In thisway, the stored datasets can optionally be accessible only to usersassociated with requests for the datasets. Optionally, a user whoprovides a query can indicate that one or more other users areauthorized to access particular requested datasets. In this way, theother users can utilize the stored datasets, thus reducing latencyassociated with their queries.

In some cases, data from the intake system 210 (e.g., ingested databuffer 310, etc.) can be stored in the acceleration data store 222. Insuch embodiments, the data from the intake system 210 can be transformedby the search nodes 506 or combined with data in the common storage 216

Furthermore, in some cases, if the query system 214 receives a querythat includes a request to process data in the query acceleration datastore 222, as well as data in the common storage 216, the search manager514 or search nodes 506 can begin processing the data in the queryacceleration data store 222, while also obtaining and processing theother data from the common storage 216. In this way, the query system214 can rapidly provide initial results for the query, while the searchnodes 506 obtain and search the data from the common storage 216.

It will be understood that the data intake and query system 108 caninclude fewer or more components as desired. For example, in someembodiments, the system 108 does not include an acceleration data store222. Further, it will be understood that in some embodiments, thefunctionality described herein for one component can be performed byanother component. For example, the search master 512 and search manager514 can be combined as one component, etc.

3.8. Metadata Catalog

FIG. 6 is a block diagram illustrating an embodiment of a metadatacatalog 221. The metadata catalog 221 can be implemented using one ormore data stores, databases, computing devices, or the like. In someembodiments, the metadata catalog 221 is implemented using one or morerelational databases, such as, but not limited to, Dynamo DB and/orAurora DB.

As described herein, the metadata catalog 221 can store informationabout datasets and/or rules used or supported by the data intake andquery system 108. Furthermore, the metadata catalog 221 can be used to,among other things, interpret dataset identifiers in a query,verify/authenticate a user's permissions and/or authorizations fordifferent datasets, identify additional processing as part of the query,identify one or more source datasets from which to retrieve data as partof the query, determine how to extract data from datasets, identifyconfigurations/definitions/dependencies to be used by search nodes toexecute the query, etc.

In certain embodiments, the query system 214 can use the metadatacatalog 221 to dynamically determine the dataset configurations and ruleconfigurations to be used to execute the query (also referred to hereinas the query configuration parameters). In certain embodiments, thequery system 214 can use the dynamically determined query configurationparameters to provide a stateless search experience. For example, if thequery system 214 determines that search heads 504 are to be used toprocess a query or if an assigned search head 504 becomes unavailable,the query system 214 can communicate the dynamically determined queryconfiguration parameters (and query to be executed) to another searchhead 504 without data loss and/or with minimal or reduced time loss.

In the illustrated embodiment, the metadata catalog 221 stores one ormore dataset association records 602, one or more dataset configurationrecords 604, and one or more rule configuration records 606. It will beunderstood, that the metadata catalog 221 can store more or lessinformation as desired. Although shown in the illustrated embodiment asbelonging to different folders or files, it will be understood, that thevarious dataset association records 602, dataset configuration records604, and rule configuration records 606 can be stored in the same file,directory, and/or database. For example, in certain embodiments, themetadata catalog 221 can include one or more entries in a database foreach dataset association record 602, dataset (or dataset configurationrecord 604), and/or rule (or rule configuration record 606). Moreover,in certain embodiments, the dataset configuration records 604 and/or therule configuration records 606 can be included as part of the datasetassociation records 602.

In some cases, the metadata catalog 221 may not store separate datasetassociation records 602. Rather the datasets association records 602shown in FIG. 6 can be considered logical associations between one ormore dataset configuration records 604 and/or one or more ruleconfiguration records 606. In some such embodiments, the logicalassociation can be determined based on an identifier or entry of eachdataset configuration record 604 and/or rule configuration record 606.For example, the dataset configuration records 604 and ruleconfiguration records 606 that begin with “shared,” can be consideredpart of the “shared” dataset association record 602A (even if separatedata structure does not physically or logically exist on a data store)and the dataset configuration records 604 and rule configuration records606 that begin with “trafficTeam,” can be considered part of the“trafficTeam” dataset association record 602N.

In some embodiments, a user can modify the metadata catalog 221 via thegateway 215. For example, the gateway 215 can receive instruction fromclient device 204 to add/modify/delete dataset association records 602,dataset configuration records 604, and/or rule configuration records606. The information received via the gateway 215 can be used by themetadata catalog 221 to create, modify, or delete a dataset associationrecord 602, dataset configuration record 604, and/or a ruleconfiguration record 606. However, it will be understood that themetadata catalog 221 can be modified in a variety of ways and/or withoutusing the gateway 215.

In certain embodiments, the metadata catalog 221 can create, modify, ordelete a dataset association record 602, dataset configuration record604, and/or a rule configuration record 606 based on an explicitinstruction to do so from a user.

In some embodiments, the metadata catalog 221 can create, modify, ordelete a dataset association record 602, dataset configuration record604, and/or a rule configuration record 606 based on a user'sinteraction with the system 108 and/or without an explicit instruction.For example, if a user enters a query in a user interface and theninstructs the system 108 to execute the query, the metadata catalog 221can create a dataset configuration record 604 based on the query and/orcan add the query as a dataset to a dataset association record 602(depending on the module that was used or identified when the query wasexecuted). With continued reference to the example, the created datasetconfiguration record 604 can include the query and indicate that thetype of dataset is a query, saved search, or view. In addition, thecreated dataset configuration record 604 can include authorizationinformation for users that are allowed to use the query or that haveaccess to the datasets referenced by the query, the identity of the userthat entered the query, the identity of a group of users with which theuser is associated, tenant information, dependency datasets, a job IDcorresponding to the job ID created by the system 108 as part ofexecuting the query, results of the query, and/or query resultsidentifier corresponding to the query results (e.g., job ID or otheridentifier that can be used to identify the query results). More or lessinformation can be determined and added to the dataset associationrecord as desired.

Similarly, if a user enters a query, the metadata catalog 221, can editthe dataset configuration record 604. With continued reference to theexample above, if another user enters the same query or the same userexecutes the query at a later time (with or without prompting by thesystem 108), the metadata catalog 221 can edit the corresponding datasetconfiguration 604. For example, the metadata catalog 221 can increment acount for the number of times the query has been used, add informationabout the users that have used the query, include a job ID, queryresults, and/or query results identifier, each time the query isexecuted, etc.

3.8.1. Dataset Association Records

As described herein, the dataset association records 602 can indicatehow to refer to one or more datasets (e.g., provide a name or otheridentifier for the datasets), identify associations or relationshipsbetween a particular dataset and one or more rules or other datasetsand/or indicate the scope or definition of a dataset. Accordingly, adataset association record 602 can include or identify one or moredatasets 608 and/or rules 610.

In certain embodiments, a dataset association record 602 can provide amechanism to avoid conflicts in dataset and/or rule identifiers. Forexample, different dataset association records 602 can use the same nameto refer to different datasets, however, the data intake and querysystem 108 can differentiate the datasets with the same name based onthe dataset association record 602 with which the different datasets areassociated. Accordingly, in some embodiments, a dataset can beidentified using a logical identifier or name and/or a physicalidentifier or name. The logical identifier may refer to a particulardataset in the context of a particular dataset association record 602.The physical identifier may be used by the metadata catalog 221 and/orthe data intake and query system 108 to uniquely identify the datasetfrom other datasets supported or used by the data intake and querysystem 108.

In some embodiments, the data intake and query system 108 can determinea physical identifier for a dataset using an identifier of the datasetassociation record 602 with which the dataset is associated. In someembodiments, the physical name can correspond to a combination of thelogical name and the name of the dataset association record 602. Incertain embodiments, the data intake and query system 108 can determinethe physical name for a dataset by appending the name of the datasetassociation record 602 to the name of the dataset. For example, if thename of the dataset is “main” and it is associated with or part of the“shared” dataset association record 602, the data intake and querysystem 108 can generate a physical name for the dataset as “shared.main”or “shared_main.” In this way, if another dataset association record 602“test” includes a “main” dataset, the “main” dataset from the “shared”dataset association record will not conflict with the “main” datasetfrom the “test” dataset association record (identified as “test.main” or“test_main”). It will be understood that a variety of ways can be usedto generate or determine a physical name for a dataset. For example, thedata intake and query system 108 can concatenate the logical name andthe name of the dataset association record 602, use a differentidentifier, etc.

In some embodiments, the dataset association records 602 can also beused to limit or restrict access to datasets and/or rules. For example,if a user uses one dataset association record 602 they may be unable toaccess or use datasets and/or rules from another dataset associationrecord 602. In some such embodiments, if a query identifies a datasetassociation record 602 for use but references datasets or rules ofanother dataset association record 602, the data intake and query system108 can indicate an error.

In certain embodiments, datasets and/or rules can be imported from onedataset association record 602 to another dataset association record602. Importing a dataset and/or rule can enable a dataset associationrecord 602 to use the referenced dataset and/or rule. In certainembodiments, when importing a dataset and/or rule 610, the importeddataset and/or rule 610 can be given a different name for use in thedataset association record 602. For example, a “main” dataset in onedataset association record can be imported to another datasetassociation record and renamed “traffic.” However, it will be understoodthat in some embodiments, the imported dataset 608 and/or rule 610 canretain the same name.

Accordingly, in some embodiments, the logical identifier for a datasetcan vary depending on the dataset association record 602 used, but thephysical identifier for the dataset may not change. For example, if the“main” dataset from the “shared” dataset association record is importedby the “test” dataset association record and renamed as “traffic,” thesame dataset may be referenced as “main” when using the “shared” datasetassociation record and may be referenced as “traffic” when using the“test” dataset association record. However, in either case, the dataintake and query system 108 can recognize that, regardless of thelogical identifier used, both datasets refer to the “shared.main”dataset.

In some embodiments, one or more datasets and/or rules can be importedautomatically. For example, consider a scenario where a rule from the“main” dataset association record 602 is imported by the “test” datasetassociation record and references dataset “users.” In such a scenario,even if the dataset “users” is not explicitly imported by the “test”dataset association record 602, the “users” dataset can be imported bythe “test” dataset association record 602. In this way, the data intakeand query system 108 can reduce the likelihood that an error occurs whenan imported dataset and/or rule references a dataset and/or rule thatwas not explicitly imported.

In certain cases, when a dataset and/or rule is automatically imported,the data intake and query system 108 can provide limited functionalitywith respect to the automatically imported dataset and/or rule. Forexample, by explicitly importing a dataset and/or rule, a user may beable to reference the dataset and/or rule in a query, whereas if thedataset and/or rule is automatically imported, a user may not be able toreference the dataset and/or rule the query. However, the data intakeand query system 108 may be able to reference the automatically importeddataset and/or rule in order to execute a query without errors.

Datasets of a dataset association record 602 can be associated with adataset type. A dataset type can be used to differentiate how tointeract with the dataset. In some embodiments, datasets of the sametype can have similar characteristics or be interacted with in a similarway. For example, index datasets and metrics interactions datasets maybe searchable, collection datasets may be searchable via a lookupdataset, view datasets may include query parameters or a query, etc.Non-limiting examples of dataset types include, but are not limited to:index (or partition), view, lookup, collections, metrics interactions,action service, interactions, four hexagonal coordinate systems, etc.

In some cases, the datasets may or may not refer to other datasets. Incertain embodiments, a dataset may refer to no other datasets, one otherdataset, or multiple datasets. A dataset that does not refer to anotherdataset may be referred to herein as a non-referential dataset, adataset that refers to one dataset may be referred to as a singlereference dataset, and a dataset that refers to multiple datasets may bereferred to as a multi-reference dataset.

In certain embodiments, some datasets can include data of the dataintake and query system 108. Some such datasets may also be referred toherein as source datasets. For example, index or partition datasets caninclude data stored in buckets as described herein. Similarly,collection datasets can include collected data. As yet another examplemetrics interactions datasets can include metrics data. In some cases, asource dataset may not refer to another dataset or otherwise identifiedas a non-referential dataset or non-referential source dataset. However,it will be understood that in certain embodiments, a source dataset canbe a single reference dataset (or single reference source dataset)and/or a multi-reference dataset (or multi-reference source dataset).

In some embodiments, certain datasets can be used to reference data in aparticular source dataset. Some such datasets may be referred to hereinas source reference datasets. For example, a source dataset may includecertain restrictions that preclude it from making its data searchablegenerally. In some such cases, a source reference dataset can be used toaccess the data of the source dataset. For example, a collection datasetmay not make its data searchable except via a lookup dataset. As such,the collection dataset may be referred to as a source dataset and thelookup dataset may be referred to as a source reference dataset. In someembodiments, a source reference dataset can correspond to or be pairedwith a particular source dataset. In certain embodiments, each sourcereference dataset references only one other (source) dataset. In suchembodiments, the source reference dataset can be referred to as a singlereference dataset or single source reference dataset. However, it willbe understood that source reference datasets can be configured in avariety of ways and/or may reference multiple datasets (and be referredto as a multi-reference dataset or multi-source reference dataset).

In certain embodiments, a dataset can include one or more queryparameters. Some such datasets may be referred to as query datasets. Forexample a view dataset can include a query that identifies a set of dataand how to process the set of data and/or one or more query parameters.When referenced, the data intake and query system 108 can incorporatethe query parameters of the query dataset into a query to beprocessed/executed by the query system 214. Similar to a query, a querydataset can reference one dataset (single reference dataset or singlereference query dataset) or multiple datasets (multi-reference datasetor multi-reference query dataset) and/or include an instruction toaccess one or more datasets (e.g., from, lookup, search, etc.).Moreover, the query dataset can include multiple query parameters toprocess the data from the one or more datasets (e.g., union, stats,count by, sort by, where, etc.)

As mentioned, in some cases, a dataset 608 in a dataset associationrecord 602 can be imported or inherited from another dataset associationrecord 602. In some such cases, if the dataset association record 602includes an imported dataset 608, it can identify the dataset 608 as animported dataset and/or it can identify the dataset 608 as having thesame dataset type as the corresponding dataset 608 from the otherdataset association record 602.

Rules of a dataset association record 602 can identify types of data andone or more actions that are to be performed on the identified types ofdata. The rule can identify the data in a variety of ways. In someembodiments, the rule can use a field-value pair, index, or othermetadata to identify data that is to be processed according to theactions of the rule. For example, a rule can indicate that the dataintake and query system 108 is to perform three processes or extractionrules on data from the “main” index dataset (or multiple or all datasetsof a dataset association record 602) with a field-value pair“sourcetype:foo.” In certain cases, a rule can apply to one or moredatasets of a dataset association record 602. In some cases, a rule canapply to all datasets of dataset association record 602. For example,the rule 610A can apply to all datasets of the shared datasetassociation record 602A or to all index type datasets of the shareddataset association record 602A, etc.

The actions of a rule can indicate a particular process that is to beapplied to the data. Similar to dataset types, each action can have anaction type. Action of the same type can have a similar characteristicor perform a similar process on the data. Non-limiting examples ofaction types include regex, aliasing, auto-lookup, and calculated field.

Regex actions can indicate a particular extraction rule that is to beused to extract a particular field value from a field of the identifieddata. Auto-lookup actions can indicate a particular lookup that is totake place using data extracted from an event to identify relatedinformation stored elsewhere. For example, an auto-lookup can indicatethat when a UID value is extracted from an event, it is to be comparedwith a data collection that relates UIDs to usernames to identify theusername associated with the UID. Aliasing actions can indicate how torelate fields from different data. For example, one sourcetype mayinclude usernames in a “customer” field and another sourcetype mayinclude usernames in a “user” field. An aliasing action can associatethe two field names together or associate both field names with anotherfield name, such as “username.” Calculated field actions can indicatehow to calculate a field from data in an event. For example, acalculated field may indicate that an average is to be calculated fromthe various numbers in an event and assigned to the field name“score_avg.” It will be understood that additional actions can be usedto process or extract information from the data as desired.

In the illustrated embodiment of FIG. 6, two dataset association records602A, 602N (also referred to herein as dataset association record(s)602), two dataset configuration records 604A, 604N (also referred toherein as dataset configuration record(s) 604), and two ruleconfiguration records 606A, 606N (also referred to herein as ruleconfiguration record(s) 606) are shown. However, it will be understoodthat fewer or more dataset association records 602 dataset configurationrecords 604, and/or rule configurations 606 can be included in themetadata catalog 221.

As mentioned, each dataset association record 602 can include a name (orother identifier) for the dataset association record 602, anidentification of one or more datasets 608 associated with the datasetassociation record 602, and one or more rules 610. As described herein,the datasets 608 of a dataset association record 602 can be native tothe dataset association record 602 or imported from another datasetassociation record 602. Similarly, rules of a dataset association record602 can be native to the dataset association record 602 and/or importedfrom another dataset association record 602.

In the illustrated embodiment, the name of the dataset associationrecord 602A is “shared” and includes the “main” dataset 608A, “metrics”dataset 608B, “users” dataset 608C, and “users-col” dataset 608D. Inaddition, the “main” dataset 608A and “metrics” dataset 608B are indexdatasets, the “users” dataset 608C is a lookup dataset associated withthe collection “users-col” dataset 608D. Moreover, in the illustratedembodiment, the “main” dataset 608A, “metrics” dataset 608B, and“users-col” dataset 608D are non-referential source datasets and the“users” dataset 608C is a source reference dataset (and single referencedataset) that references the “users-col” dataset 608D.

In addition, in the illustrated embodiment, the dataset associationrecord 602A includes the “X” rule 610A associated with the “main”dataset 608A and “metrics” dataset 608B. The “X” rule 610A uses afield-value pair “sourcetype:foo” to identify data that is to beprocessed according to an “auto lookup” action 612A, “regex” action612B, and “aliasing” action 612C. Accordingly, in some embodiments, whendata from the “main” dataset 608A is accessed, the actions 612A, 612B,612C of the “X” rule 610A are applied to data of the sourcetype “foo.”

Similar to the dataset association record 602A, the dataset associationrecord 602N includes a name (“trafficTeam”) and various native indexdatasets 608E, 608F (“main” and “metrics,” respectively), a collectiondataset 608G (“threats-col”) and a lookup dataset 608H (“threats”), anda native rule 610C (“Y”). In addition, the dataset association record602 includes a view dataset 608I (“threats-encountered”). The“threats-encountered” dataset 608I includes a query (shown in thedataset configuration record 604N) “|from traffic|lookup threats sigOUTPUT threat|where threat=*| stats count by threat” that references twoother datasets 608J, 608H (“traffic” and “threats”). Thus, when the“threats-encountered” dataset 608I is referenced, the data intake andquery system 108 can process and execute the identified query. Moreover,in the illustrated embodiment, the “main” dataset 608E, “metrics”dataset 608E, and “threats-col” dataset 608G are non-referential sourcedatasets, the “threats” dataset 608H is a single source referencedataset (source reference and single reference dataset) that referencesthe “threats-col” dataset 608G, and the “threats-encountered dataset”608I is a multi-reference query dataset.

The dataset association record 602N also includes an imported “traffic”dataset 608J and an imported “shared.X” rule 610B. In the illustratedembodiment, the “traffic” dataset 608J corresponds to the “main” dataset608A from the “shared” dataset association record 602A. As describedherein, in some embodiments, to associate the “main” dataset 608A (fromthe “shared” dataset association record 602A) with the “traffic” dataset608J (from the “trafficTeam” dataset association record 602N), the nameof the dataset association record 602A (“shared”) is placed in front ofthe name of the dataset 608A (“main”). However it will be understoodthat a variety of ways can be used to associate a dataset 608 from onedataset association record 602 with the dataset 608 from another datasetassociation record 602. As described herein, by importing the dataset“main” dataset 608A, a user using the dataset association record 602 andcan reference the “main” dataset 608A and/or access the data in the“main” dataset 608A.

Similar to the “main” dataset 608A, the “X” rule 610A is also importedby the “trafficTeam” dataset association record 602N as the “shared.X”rule 610B. As described herein, by importing “X” rule 610A, a user usingthe “trafficTeam” dataset association record 602N can use the “X” rule610A. Furthermore, in some embodiments, if the “X” rule 610A (or adataset) references other datasets, such as, the “users” dataset 608Cand the “users-col” dataset 608D, these datasets can be automaticallyimported by the “trafficTeam” dataset association record 602N. However,a user may not be able to reference these automatically imported rules(datasets) in a query.

3.8.2. Dataset Configuration Records

The dataset configuration records 604 can include the configurationand/or access information for the datasets associated with the datasetassociation records 602 or otherwise used or supported by the dataintake and query system 108. In certain embodiments, the metadatacatalog 221 includes the dataset configuration records 604 for all ofthe datasets 608 used or supported by the data intake and query system108 in one or more files or entries. In some embodiments, the metadatacatalog 221 includes a separate file, record, or entry for each dataset608 or dataset configuration record 604.

The dataset configuration record 604 for each dataset 608 can identify aphysical and/or logical name for the dataset, a dataset type,authorization information indicating users or credentials that have toaccess the dataset, access information (e.g., IP address, end point,indexer information), and/or location information (e.g., physicallocation of data) to enable access to the data of the dataset, etc.Furthermore, depending on the dataset type, each dataset configurationrecord 604 can indicate custom fields or characteristics associated withthe dataset. In some embodiments, index, metrics, lookup, and collectiondatasets may include location information, while view datasets do not.For example, in some cases view datasets may not have data except thatwhich is access via an index, metrics, lookup, and collection datasets.Accordingly, the content and information for the dataset associationrecords 602 can vary depending on the dataset type.

In the illustrated embodiment, the “shared.main” dataset configurationrecord 604A for the “shared.main” dataset 608A indicates that it is anindex data type, and includes authorization information indicating theentities that have access to the “shared.main” dataset 608A, accessinformation that enables the data intake and query system 108 to accessthe data of the “shared.main” dataset 608A, and location informationthat indicates the location where the data is located. In some cases,the location information and access information can overlap or becombined. In addition, the dataset configuration record 604A includes aretention period indicating the length of time in which data associatedwith the “shared.main” dataset 608A is to be retained by the data intakeand query system 108. In some embodiments, because “shared.main” isimported into the “trafficTeam” dataset association record 602N as thedataset “traffic,” it may also be identified as the“trafficTeam.traffic” dataset 608J. Accordingly, in some suchembodiments, the dataset configuration record 604A may include anadditional identifier for “trafficTeam.traffic” or as is shown in theillustrated embodiment, it may indicate that the “trafficTeam.traffic”dataset is a dependent dataset.

Similarly, in the illustrated embodiment, the“trafficTeam.threats-encountered” dataset configuration record 604N forthe “trafficTeam.threats-encountered” dataset 608I indicates that it isa view type of dataset and includes authorization information indicatingthe entities that have access to it. In addition, the datasetconfiguration record 604N includes the query for the“trafficTeam.threats-encountered” dataset 608I.

The dataset configuration record 604 can also include additionalinformation or metadata (also referred to herein as annotations). Theannotations can correspond to user annotations added by a user or tosystem annotations that are automatically generated by the system.

In the illustrated embodiment of FIG. 6, the dataset configurationrecord 604A includes a system annotation 614 that indicates the numberof identified fields of the “shared.main” dataset (4), a systemannotations 616 that identify the fields of the “shared.main” dataset(sig, IP_addr, userID, error), and a system annotation 618 thatidentifies the datasets that depend on the “shared.main” dataset(“trafficTeam.traffic” and “trafficTeam.threats-encountered”). In theillustrated embodiment, the dependent datasets annotation 618 includesreference to the “trafficTeam.traffic” dataset 608J even though it isonly an identifier to import the “shared.main” dataset to the datasetassociation record 602N. However, in some embodiments, datasets thatonly import another dataset or are merely identifiers for anotherdataset may not be identified as dependent datasets and/or may not beincluded as part of a system annotation.

With further reference to the illustrated embodiment of FIG. 6, thedataset configuration record 604N includes a user annotation 620 thatidentifies a group associated with the dataset“trafficTeam.threats-encountered” 608I (also referred to herein as“threats-encountered”). This annotation can be used by the system todetermine which group is responsible for the dataset 604N and/or shouldbe charged for its use. The dataset configuration record 604N alsoincludes a system annotation 622 that identifies the datasets on whichthe “threats-encountered” dataset depends (“trafficTeam.traffic,” whichis also “shared.main” and “trafficTeam.threats”), and a systemannotation 624 that identifies the number of times the“threats-encountered” dataset 608I has been used and/or accessed. Insome embodiments, because trafficTeam.traffic merely imports“shared.main” it may not be considered a related dataset or may beomitted from the dependency dataset annotation 622.

In some embodiments, the data intake and query system 108 (e.g., thequery system 214) creates a job ID each time a query is run or executed(e.g., each time a dataset is used or accessed). The job ID mayreference a specific query run at a specific time, or in reference to aspecific time, and point to results of the query. The data intake andquery system 108 (e.g., the query system 214) can store the job ID in adataset configuration record that includes the query that is run. Ingeneral, a dataset configuration record associated with a dataset thatis of the type “savedsearch/view” or any other type on which a query canbe run includes at least one job ID once the query included in datasetconfiguration record is run at least once. For example, the queryincluded in a dataset configuration record can be run one or more times.The dataset configuration record can include the job ID for the mostrecent query that is run, the job ID for the first query that is run,the job IDs for some, but not all, of the queries that are run, the jobIDs for all of the queries that are run, and/or any combination thereof.With further reference to the illustrated embodiment of FIG. 6, thesystem annotation 624 indicates that the“trafficTeam.threats-encountered” dataset 608I has been used and/oraccessed 30 times. Thus, the query included in the dataset configurationrecord 604N may have been run 30 times. In the illustrated embodiment,the dataset configuration record 604N includes a system annotation 626that identifies a job ID (“F341A5”) of the most recent query that is runon the “trafficTeam.threats-encountered” dataset 608I. In otherembodiments not illustrated, however, the dataset configuration record604N can include a system annotation 626 that identifies the job ID ofthe first query that is run on the “trafficTeam.threats-encountered”dataset 608I, job IDs of some, but not all, of the queries run on the“trafficTeam.threats-encountered” dataset 608I, job IDs of all of thequeries run on the “trafficTeam.threats-encountered” dataset 608I,and/or any combination thereof.

In some embodiments, the data intake and query system 108 (e.g., thequery system 214) includes in a dataset configuration record not onlysome or all of the job IDs of a query that is run or executed, but alsothe results of each executed query that has a job ID present in thedataset configuration record. With further reference to the illustratedembodiment of FIG. 6, the dataset configuration record 604N includes asystem annotation 628 that identifies the results of the queryassociated with the job ID identified by the system annotation 626(“F341A5”). For example, the most recent results of running the datasetconfiguration record 604N query on the “trafficTeam.threats-encountered”dataset 608I can be a count of 2 for “threat1,” a count of 5 for“threat2,” and so on. In other embodiments not illustrated, the datasetconfiguration record 604N can include the query result of the firstquery that is run on the “trafficTeam.threats-encountered” dataset 608I,the query results of some, but not all, of the queries that are run onthe “trafficTeam.threats-encountered” dataset 608I, the query results ofall of the queries that are run on the “trafficTeam.threats-encountered”dataset 608I, and/or any combination thereof. For example, if thedataset configuration record 604N includes one or more systemannotations 626 identifying multiple job IDs, then the datasetconfiguration record 604N may also include one or more systemannotations 628 identifying the results of each job ID identified by thesystem annotation(s) 626. The query results can be represented in a JSONformat, as a table, or in some other format, as desired.

In addition to the job ID and query results, a dataset configurationrecord can store additional information related to a query, such as, butnot limited to, the user that executed a query, the tenant associatedwith the query, the time the query was executed, or the time the job IDwas created, etc. The system 108 can use this information to generatestatistical information about different queries and/or providerecommendations to users. For example, the system 108 can provide queryrecommendations based on the most frequently used queries generally orby the user, or users from the same tenant, users with similaradministrative privileges or access controls, etc.

It will be understood that fewer or more annotations can be included inthe dataset configuration record 604N. For example, the datasetconfiguration record 604N can include the identity and number of fieldsused by the “threats-encountered” dataset.

It will be understood that more or less information or annotations canbe included in each dataset configuration record 604. For example, thedataset configuration records 604 can indicate whether the dataset is anon-referential, single reference or multi-reference dataset and/oridentify any datasets that it references (by the physical or logicalidentifier of the datasets or other mechanism), is dependent on or thatdepend on it, its usage, etc. As another example, the datasetconfiguration records 604 can identify one or more rules associated withthe dataset. Additional information regarding example annotations thatcan be generated and/or included in dataset configuration records 604 orin the metadata catalog 221 are described herein.

Although not illustrated in FIG. 6, it will be understood that themetadata catalog 221 can include a separate dataset configuration record604 for the datasets 608B, 608C, 608D, 608E, 608F, 608G, 608H, and 608J.Furthermore, it will be understood that the metadata catalog 221 caninclude data from multiple tenants. In some cases, the data (e.g.,dataset association records, dataset configuration records, and/or ruleconfiguration records, etc.) from different tenants can be logicallyand/or physically segregated within the metadata catalog 221.

In some embodiments, some datasets may not have a separate datasetconfiguration record 604. For example, imported datasets and/or viewdatasets may not include a separate dataset configuration record 604. Incertain embodiments, view datasets can include a query identified in adataset association record 602, but may not have a separate datasetconfiguration record 604 like index, metrics, collection, and/or lookupdatasets.

In some embodiments, the dataset configuration record 604 for the“traffic” dataset 608J (or other imported datasets) can indicate thatthe “traffic” dataset 608J is an imported version of the “shared.main”dataset 608A. In certain cases, the dataset configuration record 604 forthe “traffic” dataset 608J can include a reference to the datasetconfiguration record 604 for the “shared.main” dataset 608A and/or caninclude all of the configuration information for the “shared.main”dataset 608A. In certain embodiments, the metadata catalog 221 may omita separate dataset configuration record 604 for the “traffic” dataset608J because that dataset is an imported dataset of the “main” dataset608A from the “share” dataset association record 602A.

As described herein, although the dataset association records 602A, 602Neach include a “main” dataset 608B, 608E and a “metrics” dataset 608B,608F, the data intake and query system 108 can differentiate between thedatasets from the different dataset association records based on thedataset association record 602 associated with the datasets. Forexample, the metadata catalog 221 can include separate datasetconfiguration records 604 for the “shared.main” dataset 608A,“trafficTeam.main” dataset 608E, “shared.metrics” dataset 608B, and the“trafficTeam.metrics” dataset 608F.

3.8.3. Rule Configuration Records

The rule configuration records 606 can include the rules, actions, andinstructions for executing the rules and actions for the rulesreferenced of the dataset association records 602 or otherwise used orsupported by the data intake and query system 108. In some embodiments,the metadata catalog 221 includes a separate file or entry for each ruleconfiguration record 606. In certain embodiments, the metadata catalog221 includes the rule configuration records 606 for all of the rules 610in one or more files or entries.

In the illustrated embodiment, a rule configuration records 606N isshown for the “shared.X” rule 610A. The rule configuration record 606Ncan include the specific parameters and instructions for the “shared.X”rule 610A. For example, the rule configuration record 606N can identifythe data that satisfies the rule (sourcetype:foo of the “main” dataset608A). In addition, the rule configuration record 606N can include thespecific parameters and instructions for the actions associated with therule. For example, for the “regex” action 612B, the rule configurationrecord 606N can indicate how to parse data with a sourcetype “foo” toidentify a field value for a “customerID” field, etc. With continuedreference to the example, for the “aliasing” action 612C, the ruleconfiguration record 606N can indicate that the “customerID” fieldcorresponds to a “userNumber” field in data with a sourcetype “roo.”Similarly, for the “auto-lookup” action 612A, the rule configurationrecord 606N can indicate that the field value for the “customerID” fieldcan be used to lookup a customer name using the “users” dataset 608C and“users-col” dataset 608D.

It will be understood that more or less information can be included ineach rule configuration record 606. For example, the rule configurationrecords 606 can identify the datasets or dataset association records 602to which the rule applies, indicate whether a rule is imported, indicateinclude authorizations and/or access information to use the rule, etc.

Similar to the dataset configuration records 604, the metadata catalog221 can include rule configuration records 606 for the various rules 610of the dataset association record 602 or other rules supported for useby the data intake and query system 108. For example, the metadatacatalog 221 can include rule configuration record 606 for the “shared.X”rule 610A and the “trafficTeam.Y” rule 610C.

As described herein, the dataset association records 602, datasetconfiguration records 604, and/or rule configuration records 606 can beused by the system 108 to interpret dataset identifiers in a query,verify/authenticate a user's permissions and/or authorizations fordifferent datasets, identify additional processing as part of the query,identify one or more source datasets from which to retrieve data as partof the query, determine how to extract data from datasets, identifyconfigurations/definitions/dependencies to be used by search nodes toexecute the query, etc.

In certain embodiments, the dataset association records 602, datasetconfiguration records 604, and/or rule configuration records 606 can beused to identify primary datasets and secondary datasets. The primarydatasets can include datasets that are to be used to execute the query.The secondary datasets can correspond to datasets that are directly orindirectly referenced by the query but are not used to execute thequery. Similarly, the dataset association records 602, datasetconfiguration records 604, and/or rule configuration records 606 can beused to identify rules (or primary rules) that are to be used to executethe query.

3.8.4. Annotations

In some embodiments, the system 108 stores data without type or asunstructured data. Thus, the system 108 may not “know” or have insight(e.g., include a table or other stored information) into the content ofthe data. For example, the system 108 may not have any insight into whatfields (e.g., IP address, error code, userID, etc.) can be found inwhich datasets or what rules are related to what datasets. While it maybe advantageous for a variety of reasons to store data without type oras unstructured data and use late binding schema to query the data, thiscan result in longer query times and the use of greater processingresources during query processing and execution. To decrease query timesand/or processing resources used during a query, the system 108 candynamically add information or metadata (also referred to herein asannotations) to the metadata catalog as it is learned.

In some embodiments, the annotations can be added to the datasetconfiguration records 604, the rule configuration records 606 or as aseparate annotation entry in the metadata catalog 221, or elsewhere inthe system 108. For example, as changes are made to the metadata catalog221 or as queries are executed on the data, the system 108 can inferinformation or learn about the datasets and rules and update the datasetconfiguration records 604 and rule configuration records 606 with thisinformation. In the illustrated embodiment of FIG. 6, dynamicallygenerated annotations 614, 616, 618, 622, 624 are included as part ofthe dataset configuration records 604A, 604N. However, as mentioned, theannotations can be stored as a separate entry or data structure. Forexample, the system 108 can update or create an annotation entry foreach annotation and store the annotations in a database, such as arelational database or table of the metadata catalog 221, or elsewherein the system 108. When stored in a separate data structure, theannotations can identify any datasets or fields to which they areassociated or related.

The updated datasets configuration records 604 (or annotation entries)can be used by the system 108 to propagate annotations to relateddatasets, protect datasets from deletion, improve portability, and makerecommendations to a user and/or process additional queries as they arereceived, etc. In this way, the system 108 can provide an incrementallyevolving schema or map of the data and can enable more efficient queriesand/or reduce the amount of processing resources used during queryexecution.

3.8.4.1. Generating Annotations

In some cases, the annotations can be added to the metadata catalog 221(in dataset configuration records 604 or as annotation entries) manuallyby a user or automatically by the system 108.

It will be understood that a user can manually add a variety ofannotations (also referred to herein as “user annotations”) to themetadata catalog 221, which can be used by the system 108 to dynamicallymake user recommendations, improve query processing, and/or search time.For example, a user can add or revise a dataset configuration record 604to the metadata catalog 221 for a dataset. As part of adding/revisingthe dataset configuration record, the user can add annotations about thecapabilities of the dataset source associated with the dataset (e.g.,speed, bandwidth, parallelization, size, etc.), one or more fields ofthe dataset and one or more relationships between the fields, one ormore datasets related to the new/revised dataset, users or groupsassociated with the dataset, units or preferred units for data from thedataset, etc.

In certain embodiments, the annotations can be added automatically bythe system 108 in response to monitoring system 108 use and/or based ondetected changes to the metadata catalog 221 (also referred to herein as“system annotations”). To generate the various system annotations, thesystem 108 can use one or more processes, threads, containers, isolatedexecution environments, etc. (generically referred to as processes). Insome cases, the system 108 can use multiple processes to generate systemannotations. For example, a separate process can be used to generateannotations based on parsing a query, monitoring query execution,monitoring user/groups, monitoring applications, etc. Similarly,separate processes can be used to generate annotations based on detectedchanges to the metadata catalog 221. For example, separate processes canbe used to generate annotations in response to detecting the addition orremoval of a field, dataset, unit or preferred unit, field-datasetrelationship, inter-field relationship, inter-dataset relationship, etc.

Moreover, the various processes can communicate with each other togenerate the system annotations. For example, consider the scenariowhere one process is used to generate annotations based on parsing aquery and another process is used to generate annotations based on theidentification of a new field or new field-dataset relationship in themetadata catalog 221. If the process that parses the query identifiesand generates an annotation based on a new field for a dataset, it canalert the process that generates annotations based on new fields addedto the dataset. In this way, the system 108 can effectively increase itsknowledge or understanding of the data stored thereon, and use thisunderstanding to facilitate more effective searching of the data.

3.8.4.1.1. System Annotations Based on System Use

A variety of system annotations can be generated based on monitoringsystem use. As non-limiting examples, system annotations can beautomatically added to the metadata catalog 221 in response to parsing aquery, executing a query, tracking user interactions with the system108, tracking the use of different applications executing in the system108, or other system use monitoring, etc.

The system annotations generated based on monitoring system use can beused for a variety of functions. For example, the system annotationsgenerated based on monitoring system use can be used to track field use,dataset use, suggest fields or datasets to a user (e.g.,frequently/infrequently used fields or datasets, related fields ordatasets, similar fields or datasets, datasets that satisfy the criteriaof another dataset, such as datasets that satisfy the field criteria ofa view dataset, etc.), display similar datasets, suggest applications,identify groups or individuals responsible for the use of a particulardataset (e.g., determine charge back distribution), cost-basedoptimizations (e.g., when querying data from multiple datasets, how toprioritize which dataset to obtain first), propagate annotations torelated datasets or fields, etc.

3.8.4.1.1.1. Query Parsing

In some cases, the system 108 can parse and extract metadata fromqueries to generate system annotations. The queries can correspond toqueries entered by a user in a user interface or queries that form partof a dataset, such as a view dataset.

In some embodiments, the system 108 can use the syntax and semantics ofa query to extract metadata from the query. For example, based on theknown syntax of a query processing language, the system 108 can identifyquery commands and locations where information can be extracted, such asdataset names or identifiers, field names or identifiers, etc. Based onthe syntax and semantics of the query, the system 108 can identifyrelationships between the datasets and fields of the query. Furthermore,the system 108 can iteratively parse the identified datasets to identifyadditional datasets, fields, relationships, etc. For example, the system108 can use the dataset identifiers to identify and parse thecorresponding dataset configuration records 604 to identify additionaldatasets, fields, and/or rules.

As a non-limiting example, with reference to the query “|fromtraffic|lookup threats sig OUTPUT threat|where threat=*|stats count bythreat” of the “threats-encountered” dataset 604N, the system 108 can,based on a knowledge of the commands for the query language used,determine that “from,” “lookup,” “OUTPUT,” “where,” “stats,” and “countby” are query commands. In addition, the system 108 can, based on theknown syntax or semantics of the query language, determine that thewords following the “from,” and “lookup” commands are dataset names oridentifiers and the words following “where,” “stats,” “count by,” and“OUTPUT” are field names or identifiers. Similarly, the system 108 candetermine that the second word following the “lookup” command is a fieldname or identifier. Accordingly, the system 108 can determine that the“threats-encountered” dataset 604N references datasets“trafficTeam.traffic” and “trafficTeam.threats” and fields “threat” and“sig.” In addition, based on the dataset association records 602 or adataset configuration record 604, the system 108 can determine that“trafficTeam.traffic” is the “shared.main” dataset imported from thedataset association record 602A.

In addition to identifying the identity of datasets and fields of thequery, the system 108 can extract other metadata from the query, suchas, but not limited to, field-dataset relationships, inter-datasetrelationships, inter-field relationships, etc. In certain embodiments,the system 108 can identify relationships between the fields anddatasets of the query. For example, based on the presence and placementof the field names “sig” and “threat” in the query, the system 108 candetermine that the dataset “trafficTeam.traffic” (and “shared.main”)includes a field “sig,” and the dataset “trafficTeam.threats” includesthe fields “sig” and “threat.”

In some embodiments, the system 108 can determine inter-fieldrelationships. For example, given that the field “sig” is included inboth “trafficTeam.traffic” and “trafficTeam.threats,” the system 108 candetermine that there is a relationship between “sig” in“trafficTeam.traffic” (or “shared.main”) and “sig” in“trafficTeam.threats” (e.g., that the two “sigs” correspond to eachother).

Moreover, in some cases, the system 108 can determine inter-datasetrelationships. In some embodiments, based on the presence of the“trafficTeam.traffic” and “trafficTeam.threats” datasets in the query ofthe “threats-encountered” dataset 602N, the system 108 can determinethat the “threats-encountered” dataset 604N is related to and dependenton the “trafficTeam.traffic” and “trafficTeam.threats” datasets. Forexample, if the datasets “traffic” and “threats” do not exist or are notdefined, the “threats-encountered” dataset may return an error or beunable to function properly. In addition, the system 108 can identify arelationship between the “traffic” and “threats” datasets. For example,given that the “traffic” and “threats” datasets both have the same field“sig,” the system 108 can identify a foreign key relationship betweenthem—similar to the inter-field relationship discussed above.

As additional datasets are identified, the system 108 can parse thecorresponding dataset configuration records 604 to identify additionalrelationships. For example, the system 108 can determine that the“trafficTeam.threats” dataset is dependent on a“trafficTeam.threats-col” dataset, and that the “trafficTeam.traffic”(or “shared.main” dataset) is related to a rule “X,” which is dependenton dataset “shared.users,” which in turn depends on a dataset“shared.users-col.” Accordingly, the system 108 can iteratively parsethe dataset configurations to determine the relationships between thevarious rules and datasets of the system 108. Another non-limitingexample of parsing a query and extracting information about the datasetsand rules referenced by the query is given with reference to FIG. 14.

Based on the extracted metadata of the query (e.g., identity of fieldsand datasets, field-dataset relationships, inter-field relationships,inter-dataset relationships, etc.), the system 108 can generate one ormore annotations. In some embodiments, the system 108 can generate anannotation for each piece of extracted metadata and/or each identifiedrelationship. In certain embodiments, the system 108 can generate one ormore annotations for any one or any combination of the identified fieldsand datasets, the identified field-dataset relationships, the identifiedinter-field relationships, and/or the identified inter-datasetrelationships, etc.

As described herein, the annotations generated from the extractedmetadata of the query can be used to track field use, dataset use,suggest fields or datasets to a user (e.g., frequently/infrequently usedfields or datasets, related fields or datasets, similar fields ordatasets, datasets that satisfy the criteria of another dataset, such asdatasets that satisfy the field criteria of a view dataset, etc.),display similar datasets, suggest applications, identify groups orindividuals responsible for the use of a particular dataset (e.g.,determine charge back distribution), propagate annotations to relateddatasets or fields, etc.

3.8.4.1.1.2. Query Execution

In some embodiments, the system 108 can monitor system use during queryexecution. For example, during query execution, the system 108 can trackwhich dataset is being accessed, the amount of data of the dataset beingretrieved from a dataset source (e.g., the total number of data entriesbeing retrieved, the number of data entries by field that are retrieved,the total amount of data being retrieved, etc.), the amount ofprocessing resources used to retrieve data from the dataset source, theamount of time taken to obtain the data from the dataset source, thespeed at which data is retrieved from the dataset source, whether adataset source supports parallelization (e.g., whether the system 108can extract data from the dataset source in parallel or serially), etc.

Based on the information that is tracked during query execution, thesystem 108 can generate one or more annotations. For example, based onthe information, the system 108 can generate or update annotations aboutthe speed and size of a dataset or dataset source (e.g., the number ofdata entries in the dataset, the number of data entries for each knownfield of the dataset, total size of the dataset or dataset source,etc.), the connectivity or latency with a dataset source, etc. In someembodiments, the system 108 can generate an annotation for eachstatistic that is monitored or generate an annotation for a group or allof the statistics being tracked. As described herein, the annotationscan be stored as part of a dataset configuration record 604 or otherannotation entry.

The annotations generated based on monitoring the system 108 duringquery execution can be used to track the speed and size of datasets andthe capabilities of dataset sources. The system 108 can further use thisinformation to generate cost-based optimizations during query execution.Consider the scenario where a query indicates that data from dataset Aand dataset B are to be joined. The system 108 can use the annotationsgenerated from monitoring the system 108 during query execution todetermine which dataset to access first. For example, the annotationsmay indicate that for field 1, dataset A has significantly more dataentries or is slower than dataset B. Thus, if the query includes a joinof field 1, the system 108 can access dataset B first and use theinformation from dataset B to refine the data that is requested fromdataset A. As another example, if another query indicates that field 2of datasets A and B are to be used for a join and the annotationsindicate that dataset B has significantly more data entries than datasetA, the system 108 can pull data from dataset A first and use it torefine the query for dataset B. Furthermore, the system 108 can use acombination of annotations to determine which dataset to access first.For example, if dataset B has significantly more data for field 3 thandataset A, but dataset A is significantly slower, the system 108 maydetermine that it will take less time and be more efficient to pull datafrom dataset B first and use that to refine the query for dataset A.

3.8.4.1.1.3. User Monitoring

In some embodiments, the system 108 can monitor users as they interactwith the system 108. For example, the system 108 can monitor which usersuse the system 108, the duration of use, the frequency of use, whichdatasets are created, accessed, modified, or used by the user, whichapplications are used by the user, typical fields that are used by theuser, etc. Similarly, if a user is part of a group, the system 108 canmonitor the collective actions of the users of the group. Thisinformation can be used to generate user/group annotations. As describedherein, the annotations can be stored as part of a dataset configurationrecord 604 or other annotation entry.

The system 108 can use the user/group annotations to track usage of thesystem 108 by user or group. Furthermore, the system 108 can use theuser/group annotations to suggest fields, datasets, applications, etc.to the user or the group. For example, the system 108 can identifyfields or datasets that are related to or similar to fields or datasetstypically used by the user. As another example, if users with similarcharacteristics to the current user use certain fields, applications, ordatasets, the system 108 can recommend these fields, application, ordatasets to the user, etc. In this way, the system 108 can improve theusers understanding of the data in the system 108 and enhance the user'sability to user or query data in the system.

3.8.4.1.1.4. Application Monitoring

In certain embodiments, the system can monitor applications used on thesystem 108. For example, the system 108 can monitor which applicationsare available on the system 108, which datasets or dataset sources areused by the application, the frequency of use of applications, anidentification of applications that are frequently used together, anidentity of users or user types that use particular applications, etc.This information can be used to generate annotations.

The system 108 can use the annotations generated by monitoringapplications to track the usage of the applications and to makesuggestions to users. For example, if multiple users of a groupfrequently use one or more applications, the system 108 can recommendthe applications to other users of the group. As another example, if oneuser of a group begins using and spends significant time on oneapplication compared to time spent on other applications beforebeginning use of the “new” application, the system 108 can recommend the“new” application to other members of the group. In this way, the system108 can propagate knowledge about the system 108 and applications tovarious users and improve their understanding of the system 108 and howto use it effectively.

3.8.4.1.2. System Annotations Based on Changes to the Metadata Catalog

As mentioned, in some embodiments, system 108 annotations can be addedautomatically to the metadata catalog 221 in response to changes in themetadata catalog 221. The changes may be the result of a manual changeby a user, such as a user annotation, or an automated change by thesystem 108, such as a system 108 annotation. For example, when a useradds or revises information about a first dataset, the system 108 cancompare information about the first dataset with other information ofother datasets to identify potential relationships or similarities. If arelationship or similarity is detected, the system 108 can add anannotation to the dataset configuration record 604 (or annotation entry)of the first dataset as well as to the dataset configuration records 604of the other identified datasets. As another example, if the system 108updates information for the first dataset based on a query, the system108 can identify other datasets that are related to the first datasetand update metadata of the other identified datasets. In this way, asthe system 108 is used, it can learn about the datasets, and use theinformation to improve search time or search capabilities. As describedherein, in some cases, the system 108 can use one or more processes toidentify the change to the metadata catalog 221 and generate additionalannotations based on the change.

In some embodiments, based on the addition of a dataset, the system 108can identify fields of the dataset, related datasets (datasets on whichthe dataset depends), similar datasets (e.g., datasets with similarfields), dataset to which the new dataset can be mapped (e.g., viewdatasets to which the new dataset can be mapped), etc. In certainembodiments, if the added dataset is a view dataset that includes aquery, the system 108 can process the query as described above togenerate one or more annotations.

In certain embodiments, based on the addition of a field-datasetrelationship annotation or the identification of a field of a dataset,the system 108 can determine a total number of fields of the dataset,identify similar datasets and/or datasets to which the dataset can bemapped, and generate corresponding annotations. For example, based onthe addition of the field “userID” to the dataset “Logons,” the system108 can identify other datasets with a “userID” field. If found, thesystem 108 can generate an annotation for the dataset “Logons” and/orthe other dataset to indicate a similar field is located in eachdataset. As another example, based on the addition of the field “userID”to the dataset “Logons,” the system 108 can identify view datasets thatuse the field “userID” to generate a view or interface. If the viewdataset uses additional fields that are also found in the “Logons”dataset, the system 108 can generate an annotation for the dataset“Logons” and/or the other dataset to indicate that the view dataset maybe related or usable with the “Logons” dataset or that the “Logon”dataset may be mapped to the view dataset.

In certain embodiments, based on the addition of an inter-fieldrelationship or inter-dataset annotation, the system 108 can identifyadditional inter-field and inter-dataset relationships. For example ifdataset A is dependent on dataset B and dataset B is dependent ondataset C, the system 108 can determine that dataset A is dependent ondataset B and generate an additional inter-dataset annotation indicatingA's dependency on C. As another example, if field “userID” of dataset Bis related to field “ID” of dataset C and a new relationship betweenfield “ID” of dataset C and field “UID” of dataset D, the system 108 candetermine that “userID” of dataset B is related to “UID” of dataset D.

In addition, based on the addition of an inter-dataset annotation, thesystem 108 can propagate one or more annotations. For example, if analarm threshold, unit, or preferred unit is associated with a metricsdataset A and an inter-dataset relationship annotation is added thatrelates metrics dataset A with metrics dataset B, the system 108 canpropagate the alarm threshold, unit, and/or preferred unit to metricsdataset B. Specifically, if an annotation for metric cpu_speed ofdataset A indicates that the units are Hz and the preferred units areGHz, the system 108 can propagate the Hz and GHz units/preferred unitsto a corresponding cpu_speed metric of dataset B. Similarly, if a datacategory annotation for a dataset or field of a dataset indicates thatthe information is confidential, then based on an inter-fieldrelationship that indicates another field is derived from theconfidential field or an inter-dataset relationship that indicatesanother dataset uses the confidential information, the system 108 canpropagate the data category annotation to the related field or dataset.

In some embodiments, based on the addition of an inter-datasetannotation, the system 108 can generate an annotation indicating thatthe dataset that is depended on should not be deleted so long as thedependent dataset exists or an annotation indicating that if the datasetthat is depended on is deleted then the dependent dataset should also bedeleted. The system can also use an inter-dataset annotation to generatean annotation that indicates the total number (and identity) of datasetsthat depend on a particular dataset, or the total number (and identity)of datasets on which the particular dataset depends.

In certain embodiments, based on an update to the field use for a field,the system 108 can compare the field use of the field with the field useof other fields and determine the popularity of the fields. Based on thepopularity, the system 108 can generate one or more annotationsindicating the popularity of the fields. Similarly, the system 108 canuse the dataset use and application use to generate annotationsindicating the popularity of different datasets and applications,respectively. In addition, using the user or group information, thesystem 108 can determine the popularity of fields, datasets, and/orapplications for a particular user or group.

In certain embodiments, based on a change/addition of a unit orpreferred unit for a dataset, the system 108 can identify relateddatasets and generate annotations for the units and preferred units forthe related datasets. Similarly, the system 108 can generate annotationsfor one or more datasets or fields in response to change/additions ofalarm thresholds or data category (e.g., use restrictions) annotationsto a related dataset or field.

3.8.4.2. Example Annotations

As mentioned, the metadata catalog 221 can include annotations orinformation about the datasets, fields, users, or applications of thesystem 108 and can be revised as additional information is learned.Non-limiting examples of annotations that can be added to the datasetconfiguration records 604, other configurations, annotation tables orentries, or other locations of the metadata catalog 221 or system 108,include but are not limited to, the identification and use of fields ina dataset, number of fields in a dataset, related fields, relateddatasets, number (and identity) of dependent datasets, number (andidentity) of datasets depended on, capabilities of a dataset or relateddataset source or provider, the identification of datasets with similarconfigurations or fields, units or preferred units of data obtained froma dataset, alarm thresholds, data categories (e.g., restrictions), usersor groups, applications, popular field, datasets, and applications (intotal or by user or group), etc. In certain cases, the annotations canbe added as the system 108 monitors system use (e.g., processingqueries, monitoring query execution, user interaction, etc.) or as thesystem 108 detects changes to the metadata catalog 221 (e.g., onemanual/automated change can lead to another automated change), etc.

3.8.4.2.1. Field Annotations

The metadata catalog 221 can store various annotations about the fieldsfound in datasets. For example, the metadata catalog 221 can include anidentification of the dataset associated with a field (or field-datasetrelationship), the number of fields of a dataset (or field count), anidentification of all fields of a dataset, the frequency of use of thedifferent fields, users of the field, etc. As described herein, theinformation about the fields of a dataset can be stored as part of adataset configuration record 604 or as part of a separate datastructure. When stored as a separate data structure, the data structurecan identify the datasets that include the field or are otherwiseassociated with or related to the field.

The number and identity of fields of a dataset can be identified in avariety of ways. In some cases, a user can manually include or add afield to the metadata catalog 221 (e.g., the dataset configurationrecord 604 or an annotation entry). For example, the user may add orrelate a regex rule to a dataset. The regex rule can define how toextract field values for the field from the dataset. Based on theinformation in the regex rule, the system 108 can identify the field andincrement the number of fields associated with the dataset.

In some embodiments, the system 108 can parse a query to identify fieldsof a dataset. As described herein, in parsing the query, the system 108can identify phrases or use the syntax of the query to identify (andcount the number of) fields. For example, with reference to the query“|from traffic|lookup threats sig OUTPUT threat|where threat=*|statscount by threat.” of threats-encountered dataset 604N, the system 108can, based on the query language used, identify “from” and “lookup” ascommands and determine that the words after “from” and “lookup,”respectively, identify a dataset and the words after “threats” and“OUTPUT,” respectively, identify a field. Accordingly, the system 108can infer that the dataset “traffic” has a field “sig” and a dataset“threats” has fields “sig” and “threat.” In some embodiments, based onthis inference, the system 108 can update the dataset configurationrecord 604 of the dataset “traffic” or generate a field-datasetrelationship annotation in the metadata catalog 221 with fieldinformation that identifies “sig” as a field associated with dataset“traffic.” Similarly, the system 108 can update the metadata catalog 221with a field-dataset annotation that identifies “sig” and “threat” asfields of the dataset “threats.” Additionally, the system 108 canidentify other fields in a query based on the syntax of the query. Witheach new field, the system 108 can update the corresponding datasetconfiguration record 604 and/or update a table that stores fieldinformation of fields in the system 108.

As queries are executed or the fields are used, the system 108 canfurther revise the dataset configuration records 604 or field entries toreflect the use of the fields over time. In this way, the system 108 cantrack the fields in the system 108, the relationship of the fields todatasets, and the frequency of use of the fields.

The system 108 can use the metadata related to the fields for a varietyof functions. In some cases, the system 108 can use the metadata relatedto the fields to make field recommendations to a user, identify datasetswith similar fields, suggest datasets for use together, identifydatasets with a particular field, etc.

In some embodiments, as a user is typing a query related to a dataset,the system 108 can use the identified fields of the dataset to indicateto the user which fields are known about that dataset. In this way, thesystem 108 can provide insight into the content of a dataset as the userenters a query. Moreover, based on information of which fields are usedmost frequently, the system 108 can recommend or more prominentlydisplay a field to the user. For example, if the system 108 hasdetermined (and the dataset configuration record 604 indicates) that thedataset “main” has at least three fields: “userID,” “IP address,” and“errorCode,” then as the user is typing out the query “from main groupby . . . ” the system 108 can display “userID,” “IP address,” and“errorCode.” Furthermore, if the system 108 has determined that “userID”is the most frequently used field (in total, by the user, or by a groupassociated with the user) related to “main” and/or most frequently usedafter “group by,” then the system 108 can suggest “userID” first orplace it more prominently relative to the other fields. In this way, thesystem 108 can aid the user in crafting a query for the system 108 toexecute based on information that the system 108 has iteratively learnedabout the data.

In certain cases, the system 108 can use the annotations related to thefields to identify datasets with similar fields and suggest use ofdatasets for views for queries. For example, if a first dataset withfields: “userID,” “productID,” and “viewTime,” is used to generate aview (or mapped to a view dataset), the system 108 can use the datasetconfiguration records 604 to compare the fields of the first datasetwith fields of other datasets. If a second dataset is identified thatincludes the fields “userID,” “productID,” and “viewTime,” the system108 can recommend the second dataset to the user for viewing and/orannotate the dataset configuration records 604 of the first and seconddataset to indicate the existence of another dataset with similarfields. As another example, if a first dataset is a view dataset thatuses the fields “userID,” “productID,” and “viewTime” from a seconddataset to generate a view or UI, the system 108 can identify otherdatasets with the fields “userID,” “productID,” and “viewTime,” andsuggest the identified datasets to the user of the view dataset. In thisway, the system 108 can track similar datasets and identify potentiallyrelated datasets.

In some cases, a user may want to execute a query using a particularfield. As the user enters a field identifier, the system 108 can suggestor identify datasets that include the particular field. In this way, thesystem 108 can aid the user in understanding the content of the databased on information that the system has iteratively learned about thedata.

In certain embodiments, the system 108 can use the number of fields toestimate a size of a particular dataset.

3.8.4.2.2. Inter-Field Relationship Annotations

The metadata catalog 221 can store information about relationshipsbetween fields of datasets. In certain embodiments, the relationshipscan correspond to one field being derived from another field, fieldswith matching, corresponding, or correlating field values, etc. Asdescribed herein, annotations about the relationship between fields ofdatasets can be stored as part of a dataset configuration record 604 oras part of a separate data structure. When stored as a separate datastructure, the data structure can identify the datasets that include thefield or are otherwise associated with or related to the field.

In some cases, when storing the inter-field relationship annotations,the system 108 can store an ID for the relationship (e.g., name orunique name for the relationship), identifiers for the datasetsassociated with the related fields, and identifiers for the fields ofthe datasets that are related. In addition, the system 108 can store arelationship type. In some embodiments, the relationship type may be anexact relationship, such that field values of the different fields match(e.g., the field value for a “UID” field of one dataset matches thefield value for an “ID” field of another dataset). In certainembodiments, the relationship type may be correlated, such as a fieldvalue of “time” in one dataset that is the most recent in time andbefore a field value of “_time” in another dataset. In some embodiments,the relationship type may be a complex relationship, such as thecombination of field values from multiple fields in one dataset to onefield value of one field in another dataset.

The relationships between fields can be identified in a variety of ways.In some cases, a user can manually include or add an inter-fieldrelationship annotation to the metadata catalog 221 (e.g., the datasetconfiguration record 604 or an annotation entry).

In some embodiments, the system 108 can parse a query or dataset toidentify relationships between fields. Similar to the identification offields described herein, the system 108 can use the syntax of the queryto identify relationships between fields. For example, with continuedreference to the query of the threats-encountered dataset 604N, based onthe identification of a “sig” field in the datasets “traffic” and“threats,” the system 108 can determine that there is a relationship orforeign-key relationship between the “sig” field of “traffic” and the“sig” field of “threats.” In some such cases, based on the existence ofthe “sig” field in both datasets and its use in the same query, thesystem 108 can determine that field values in the “sig” field of“traffic” match the field values in the “sig” field of “threats.” Assuch, the system 108 can identify and store information about therelationship in the metadata catalog 221.

As another example, based on a query or parsing a dataset, the system108 can identify fields derived from other fields. For example, a querymay initially refer to a field “salary.” Field values of the field“salary,” may be transformed and/or combined with other data as part ofthe query and later referenced as the field “sum.” In some such cases,by parsing the syntax of the query, the system 108 can identify therelationship between “sum” and “salary” and identify “sum” as a fieldderived from “salary.” As such, the system 108 can identify and storeinformation about the relationship in the metadata catalog 221.

In certain embodiments, the system 108 can identify inter-fieldrelationships based on changes to the metadata catalog 221. For exampleif the metadata catalog 221 identifies a relationship between fields Aand B (e.g., field B is derived from field A) and a new inter-fieldrelationship annotation is added indicating a relationship betweenfields B and C (e.g., field C is derived from field B), the system 108can determine and generate an inter-field relationship annotation forfields A and C (e.g., field C is derived from field A).

The system 108 can use the inter-field relationship annotations topropagate additional annotations. With continued reference to the “sum”and “salary” field example above, if the “salary” field is indented aspersonally identifiable information or is otherwise subject torestrictions, the system 108 can use the relationship information toalso mark the “sum” field as PII or restricted. As another example, ifunits or preferred units are identified for one field, the system 108can use the identification of related fields to automatically identifyunits or preferred units for the field. By iteratively learning andstoring information about relationships between fields, the system 108can iteratively learn about the various connections between fields andimprove compliance with data restrictions.

3.8.4.2.3. Inter-Dataset Relationship Annotations

The metadata catalog 221 can store annotations about relationshipsbetween datasets. In some embodiments, a dataset configuration record604 of a first dataset can include the number and/or identification ofrelated datasets, such as datasets that depend on the first dataset ordatasets on which the first dataset depends. For example, if a firstdataset refers to or uses data from a second dataset, the datasetconfiguration record 604 of the first dataset and the second dataset canidentify the first dataset as being dependent on the second dataset. Incertain embodiments, certain metrics data may be identified as beingrelated to certain raw machine data datasets. As such the datasetconfiguration records 604 of the metrics data and raw machine datadatasets can identify each other as being related. As described herein,in some cases, fields of different datasets may be related or correspondto each other. As such, based on the relationship between the fields,the metadata catalog 221 can identify the datasets as being related. Asdescribed herein, annotations about the relationship between fields ofdatasets can be stored as part of a dataset configuration record 604 oras part of a separate data structure. When stored as a separate datastructure, the data structure can identify the datasets that include thefield or are otherwise associated with or related to the field.

The relationships between datasets can be identified in a variety ofways. In some cases, a user can manually include or add a relationshipbetween datasets to a dataset configuration record 604 and/or anannotation entry.

In certain embodiments, the system 108 can parse a query or dataset toidentify relationships between datasets. For example, with continuedreference to the threat-encountered dataset 604N, the system 108 canparse the query “|from traffic lookup|threats sig OUTPUT threat|wherethreat=*|stats count by threat.” In parsing the query, the system 108can use the syntax of the query language to identify datasets andrelationships. For example, “from” and “lookup” can be commands andwords following those commands can identify datasets. Accordingly, thesystem 108 can identify the datasets “trafficTeam.traffic” (which is the“shared.main” dataset imported from dataset association record 602A) and“trafficTeam.threats” from the query. Furthermore, the system 108 candetermine that the threats-encountered dataset 604N is dependent on the“trafficTeam.traffic” and “trafficTeam.threats” datasets given thatthose datasets are used in the threats-encountered query. In otherwords, without the datasets “trafficTeam.traffic” and“trafficTeam.threats,” the “threats-encountered” dataset would notfunction properly or would return an error.

In addition, the system 108 can identify a relationship between the“trafficTeam.traffic” and “trafficTeam.threats” datasets. For example,given that the “trafficTeam.traffic” and “trafficTeam.threats” datasetsboth have the same field “sig,” the system 108 can identify a foreignkey relationship between them and store a correspondingannotation—similar to the inter-field relationship field annotation.

In certain embodiments, the system 108 can identify inter-datasetrelationships based on changes to the metadata catalog 221. For example,if the metadata catalog 221 identifies a relationship between dataset Aand B (non-limiting examples: (1) dataset B depends from dataset A, (2)dataset A can be mapped to dataset B, (3) dataset A and B have similarfields) and a new inter-field relationship annotation is addedindicating a relationship between datasets B and C (non-limitingexamples: (1) dataset C depends from dataset B, (2) dataset C can bemapped to dataset B, (3) dataset B can be mapped to dataset C), thesystem 108 can determine and generate an inter-dataset relationshipannotation for datasets A and C (non-limiting examples: (1) dataset Cdepends from dataset A, (2) dataset A and C have similar fields, (3)dataset A can be mapped to dataset C).

The inter-dataset relationship annotations can be used for a variety offunctions. In some cases, the system 108 can use the inter-datasetrelationship annotations to generate additional annotations (e.g.,additional inter-dataset relationships as described above), to propagateannotations from one dataset to another dataset (e.g., if units orpreferred units are identified for dataset one then the units orpreferred units may also be used for related dataset two), to lockdatasets from or identify datasets for deletion (e.g., if dataset onedepends on dataset two then dataset two should not be deleted or ifdataset one depends on dataset two and dataset two is to be deleted thendataset one should also be deleted).

In certain embodiments, the system 108 can use the inter-datasetrelationship annotations to propagate annotations from one dataset toanother. For example, if dataset one is annotated as containingrestricted information, the system 108 can use the inter-datasetrelationship annotations to identify and annotate other datasets thatdepend from dataset one. As another example, if data from one dataset isannotated with a particular unit or preferred unit (e.g., MB instead ofbytes), the system 108 can use the inter-dataset relationshipannotations to identify other datasets that can be similarly annotated.Similarly, alarm thresholds for one dataset may be propagated to relateddatasets, etc.

3.8.4.2.4. Dataset Properties Annotations

The metadata catalog 221 can store annotations about the properties of adataset, such as, but not limited to, an (estimated) size of a dataset,the usage of the dataset, and/or the capabilities of the dataset ordataset source. In some embodiments as users interact with the datasets,the system 108 can track when a dataset is used, the frequency of itsuse, the users or groups that use the dataset, etc. In addition, as adataset is used, the metadata catalog 221 can estimate its size as itlearns about the number of fields in the dataset and/or track the amountof data obtained from the dataset. In some cases, as data is extractedfrom datasets or dataset sources, the system 108 can monitor theperformance of the dataset or dataset source. For example, the system108 can monitor the speed of the dataset source, its bandwidth, networkconnectivity, etc. Based on this information, the system 108 candetermine a cost to access a particular dataset. The cost may refer totime, computing resources, etc. This information can be stored as anannotation entry or as part of a dataset configuration record 604 asdescribed herein.

Using the usage annotations, the system 108 can make recommendations toa user. For example, based on the frequency of use of dataset one or thenumber of datasets that refer to or depend from dataset one, the system108 can recommend that dataset one be used for a particular query by theuser.

Using the estimated size, speed, cost, or capability of a dataset, thesystem 108 can allocate resources for a query that depends on thedataset. For example, the system 108 can allocate more resources if itdetermines that the dataset is relatively large, slow, or supportsparallelization, or allocate fewer resources if it determines that thedataset is relatively small or fast or does not support parallelization,etc. In addition, the system 108 can use the capabilities of the datasetto perform cost-based optimizations. For example, if, based on a query,the system 108 is to join data from dataset A and dataset B, based onthe size, speed, etc. of the datasets, the system 108 can determinewhich dataset to access first. If, for example, dataset A is smaller orfaster than dataset B, the system 108 can determine that dataset Ashould be accessed first and the results of dataset A can be used torefine the query to dataset B.

3.8.4.2.5. Normalization Annotations

The metadata catalog 221 can store normalization annotations about thedatasets. In some cases, datasets may not be explicitly related, but mayinclude similar data or fields. In some such cases, the system 108 cananalyze the datasets to identify similar datasets or dataset thatinclude similar data or fields.

In some cases, the metadata catalog 221 can identify similar datasets bycomparing fields of datasets. As field annotations are added to themetadata catalog 221, as described herein, the system 108 can comparethe fields of one dataset with the fields of another dataset. If athreshold number of fields are the same, then the system 108 cangenerate a normalization annotation (or inter-dataset relationshipannotation) indicating that the datasets include similar data. Thethreshold number can be based on the total number of fields in one orboth datasets or the number of fields used in another dataset, such as aview dataset.

In certain embodiments, as datasets are added, such as a view datasetthat references dataset 1, the fields used by the view dataset can becompared with the fields of other datasets in the metadata catalog 221.If dataset 2 includes the same or similar fields to those used by theview dataset from dataset 1, the system 108 can generate a normalizationannotation (or inter-dataset relationship annotation) indicating thesimilarity of dataset 2 to dataset 1 and/or indicate that dataset 2could be used with the view dataset.

The normalization annotations can be used by the system 108 to makesuggestions to a user about which datasets can be used with otherdatasets, such as view datasets, or to suggest that a user review adataset. For example, as a user views an interface resulting frommultiple fields from dataset 1 being mapped to a view dataset, thesystem 108 can recommend to the user that dataset 2 may provideadditional results that may be helpful to the user's analysis of dataset1.

3.8.4.2.6. Unit Annotations

The metadata catalog 221 can store unit annotations about the datasetsor fields of the datasets. In some cases, the system 108 can identifythe unit annotations based on user input and/or based on analysis ofrelated datasets. In certain embodiments, a user can indicate that datafrom a particular dataset or field has a particular unit and/or has apreferred unit. For example, a user can indicate that the unit for aparticular metric is Hz and/or that the preferred unit for the metric isMHz or GHz. The unit and/or preferred unit can be stored by the system108 as a unit annotation. As described herein, the unit annotation canbe stored as part of a dataset configuration record 604 and/orannotation entry.

In some embodiments, the system 108 can determine unit annotations basedon changes to the metadata catalog 221. For example, if datasets A and B(or a field or metric of dataset A and B) are related and a newannotation is added indicating a preferred unit for dataset A (or ametric or field of dataset A), the system 108 can automaticallydetermine and generate an annotation for dataset B (or a metric or fieldof dataset B) indicating the same preferred unit.

The unit annotations can be used by the system 108 to convert and/ordisplay the data in a particular way. For example, if the unitannotation for a field or metric is identified as a byte and thepreferred unit is a gigabyte, the system 108 can convert the bytes fromthe dataset to gigabytes and display the data as a gigabyte.Furthermore, the system 108 can propagate a unit annotation from onedataset to other datasets. In certain embodiments, the system 108 canidentify fields or datasets related to the annotated field or datasetand propagate the unit annotation to the identified field or dataset.

3.8.4.2.7. Alarm Threshold Annotations

The metadata catalog 221 can store alarm threshold annotations about thedatasets or fields of the datasets. In some cases, the system 108 canidentify the alarm threshold annotations based on user input or based onprevious user actions. For example, a user can indicate that when aparticular metric or value satisfies a threshold, a person should bealerted or an alarm sounded.

In some embodiments, the system 108 can determine alarm thresholdannotations based on changes to the metadata catalog 221. For example,if datasets A and B (or a field or metric of dataset A and B) arerelated and a new annotation is added indicating an alarm threshold fordataset A (or a metric or field of dataset A), the system 108 canautomatically determine and generate an annotation for dataset B (or ametric or field of dataset B) indicating the same alarm threshold.

The alarm threshold annotations can be used by the system 108 togenerate alarms or automatically execute a query. For example, based onan alarm threshold being satisfied, the system 108 can execute a querythat surfaces information related to the alarm threshold. In addition,the system 108 can propagate the alarm thresholds to related datasets orfields.

3.8.4.2.8. Data Category Annotations

The metadata catalog 221 can store data category annotations about thedatasets or fields of the datasets. In some cases, the system 108 canidentify the data category (or use restriction) annotations based onuser input. For example, a user can indicate that a particular field ordataset includes personally identifiable information, should beseparately tracked or monitored, etc. Based on the identification, thesystem 108 can store a data category annotation for that field ordataset.

In some embodiments, the system 108 can determine data categoryannotations based on changes to the metadata catalog 221. For example,if datasets A and B (or a field or metric of dataset A and B) arerelated and a new annotation is added indicating a data category fordataset A (or a metric or field of dataset A), the system 108 canautomatically determine and generate an annotation for dataset B (or ametric or field of dataset B) indicating the same data category. Forinstance, consider a scenario where dataset A includes a“social_security_num” field and a data category annotation indicatingthat the field is PII, and dataset B includes an “ID” field. If themetadata catalog is updated to reflect that the “ID” field is derivedfrom the “social_security_num” field, then the system can automaticallypropagate the data category for the “social_security_num” field to the“ID” field.

The data category annotations can be used by the system 108 to track howcertain data is being used and/or for compliance purposes. For example,the system can monitor PII data and generate alerts if it is notproperly stored or processed.

3.8.4.2.9. User/Group Annotations

The metadata catalog 221 can store user or group annotations. In somecases, the system 108 can identify the user/group annotations based onuser input. For example, a user can indicate that a particular user orgroup is associated with a particular dataset. In certain embodiments,the system 108 can generate the user/group annotations based on usageinformation. For example, the system 108 can track which datasets areaccessed by which users or groups of users. This information can bestored as user/group annotations. As yet another example, if aparticular user or group is the most frequent user of a dataset, thesystem 108 can relate the user or group to the dataset and generate auser/group annotation.

The user/group annotations can be used by the system 108 to determinehow usage time should be allocated between parties. For example, iftwenty users have access to a dataset, the system 108 can track which ofthe users or groups used the dataset most frequently and should becharged for the usage.

3.8.4.2.10. Application Annotations

The metadata catalog 221 can store application annotations. In certainembodiments, the system 108 can generate the application annotationsbased on usage information. For example, the system 108 can track whichapplications are used by which users and with what datasets. Thisinformation can be stored as application annotations as part of adataset configuration record 604 or annotation entry.

The application annotations can be used by the system 108 to makerecommendations to users. For example, if a threshold number of usersfrequently use three applications and a different user frequently usestwo of the three applications, the system 108 can recommend the thirdapplication to the user.

4.0. Data Intake and Query System Functions

As described herein, the various components of the data intake and querysystem 108 can perform a variety of functions associated with theintake, indexing, storage, and querying of data from a variety ofsources. It will be understood that any one or any combination of thefunctions described herein can be combined as part of a single routineor method. For example, a routine can include any one or any combinationof one or more data ingestion functions, one or more indexing functions,and/or one or more searching functions.

4.1 Intake

As discussed above, ingestion into the data intake and query system 108can be facilitated by an intake system 210, which functions to processdata according to a streaming data model, and make the data available asmessages on an output ingestion buffer 310, categorized according to anumber of potential topics. Messages may be published to the outputingestion buffer 310 by a streaming data processors 308, based onpreliminary processing of messages published to an intake ingestionbuffer 306. The intake ingestion buffer 306 is, in turn, populated withmessages by one or more publishers, each of which may represent anintake point for the data intake and query system 108. The publishersmay collectively implement a data retrieval subsystem 304 for the dataintake and query system 108, which subsystem 304 functions to retrievedata from a data source 202 and publish the data in the form of amessage on the intake ingestion buffer 306. A flow diagram depicting anillustrative embodiment for processing data at the intake system 210 isshown at FIG. 7. While the flow diagram is illustratively described withrespect to a single message, the same or similar interactions may beused to process multiple messages at the intake system 210.

4.1.1 Publication to Intake Topic(s)

As shown in FIG. 7, processing of data at the intake system 210 canillustratively begin at (1), where a data retrieval subsystem 304 or adata source 202 publishes a message to a topic at the intake ingestionbuffer 306. Generally described, the data retrieval subsystem 304 mayinclude either or both push-based and pull-based publishers. Push-basedpublishers can illustratively correspond to publishers whichindependently initiate transmission of messages to the intake ingestionbuffer 306. Pull-based publishes can illustratively correspond topublishers which await an inquiry by the intake ingestion buffer 306 formessages to be published to the buffer 306. The publication of a messageat (1) is intended to include publication under either push- orpull-based models.

As discussed above, the data retrieval subsystem 304 may generate themessage based on data received from a forwarder 302 and/or from one ormore data sources 202. In some instances, generation of a message mayinclude converting a format of the data into a format suitable forpublishing on the intake ingestion buffer 306. Generation of a messagemay further include determining a topic for the message. In oneembodiment, the data retrieval subsystem 304 selects a topic based on adata source 202 from which the data is received, or based on thespecific publisher (e.g., intake point) on which the message isgenerated. For example, each data source 202 or specific publisher maybe associated with a particular topic on the intake ingestion buffer 306to which corresponding messages are published. In some instances, thesame source data may be used to generate multiple messages to the intakeingestion buffer 306 (e.g., associated with different topics).

4.1.2 Transmission to Streaming Data Processors

After receiving a message from a publisher, the intake ingestion buffer306, at (2), determines subscribers to the topic. For the purposes ofexample, it will be associated that at least one device of the streamingdata processors 308 has subscribed to the topic (e.g., by previouslytransmitting to the intake ingestion buffer 306 a subscription request).As noted above, the streaming data processors 308 may be implemented bya number of (logically or physically) distinct devices. As such, thestreaming data processors 308, at (2), may operate to determine whichdevices of the streaming data processors 308 have subscribed to thetopic (or topics) to which the message was published.

Thereafter, at (3), the intake ingestion buffer 306 publishes themessage to the streaming data processors 308 in accordance with thepub-sub model. This publication may correspond to a “push” model ofcommunication, whereby an ingestion buffer determines topic subscribersand initiates transmission of messages within the topic to thesubscribers. While interactions of FIG. 7 are described with referenceto such a push model, in some embodiments, a pull model of transmissionmay additionally or alternatively be used. Illustratively, rather thanan ingestion buffer determining topic subscribers and initiatingtransmission of messages for the topic to a subscriber (e.g., thestreaming data processors 308), an ingestion buffer may enable asubscriber to query for unread messages for a topic, and for thesubscriber to initiate transmission of the messages from the ingestionbuffer to the subscriber. Thus, an ingestion buffer (e.g., the intakeingestion buffer 306) may enable subscribers to “pull” messages from thebuffer. As such, interactions of FIG. 7 (e.g., including interactions(2) and (3) as well as (9), (10), (16), and (17) described below) may bemodified to include pull-based interactions (e.g., whereby a subscriberqueries for unread messages and retrieves the messages from anappropriate ingestion buffer).

4.1.3 Messages Processing

On receiving a message, the streaming data processors 308, at (4),analyze the message to determine one or more rules applicable to themessage. As noted above, rules maintained at the streaming dataprocessors 308 can generally include selection criteria indicatingmessages to which the rule applies. This selection criteria may beformatted in the same manner or similarly to extraction rules, discussedin more detail below, and may include any number or combination ofcriteria based on the data included within a message or metadata of themessage, such as regular expressions based on the data or metadata.

On determining that a rule is applicable to the message, the streamingdata processors 308 can apply to the message one or more processingsub-rules indicated within the rule. Processing sub-rules may includemodifying data or metadata of the message. Illustratively, processingsub-rules may edit or normalize data of the message (e.g., to convert aformat of the data) or inject additional information into the message(e.g., retrieved based on the data of the message). For example, aprocessing sub-rule may specify that the data of the message betransformed according to a transformation algorithmically specifiedwithin the sub-rule. Thus, at (5), the streaming data processors 308applies the sub-rule to transform the data of the message.

In addition or alternatively, processing sub-rules can specify adestination of the message after the message is processed at thestreaming data processors 308. The destination may include, for example,a specific ingestion buffer (e.g., intake ingestion buffer 306, outputingestion buffer 310, etc.) to which the message should be published, aswell as the topic on the ingestion buffer to which the message should bepublished. For example, a particular rule may state that messagesincluding metrics within a first format (e.g., imperial units) shouldhave their data transformed into a second format (e.g., metric units)and be republished to the intake ingestion buffer 306. At such, at (6),the streaming data processors 308 can determine a target ingestionbuffer and topic for the transformed message based on the ruledetermined to apply to the message. Thereafter, the streaming dataprocessors 308 publishes the message to the destination buffer andtopic.

For the purposes of illustration, the interactions of FIG. 7 assumethat, during an initial processing of a message, the streaming dataprocessors 308 determines (e.g., according to a rule of the dataprocessor) that the message should be republished to the intakeingestion buffer 306, as shown at (7). The streaming data processors 308further acknowledges the initial message to the intake ingestion buffer306, at (8), thus indicating to the intake ingestion buffer 306 that thestreaming data processors 308 has processed the initial message orpublished it to an intake ingestion buffer. The intake ingestion buffer306 may be configured to maintain a message until all subscribers haveacknowledged receipt of the message. Thus, transmission of theacknowledgement at (8) may enable the intake ingestion buffer 306 todelete the initial message.

It is assumed for the purposes of these illustrative interactions thatat least one device implementing the streaming data processors 308 hassubscribed to the topic to which the transformed message is published.Thus, the streaming data processors 308 is expected to again receive themessage (e.g., as previously transformed the streaming data processors308), determine whether any rules apply to the message, and process themessage in accordance with one or more applicable rules. In this manner,interactions (2) through (8) may occur repeatedly, as designated in FIG.7 by the iterative processing loop 704. By use of iterative processing,the streaming data processors 308 may be configured to progressivelytransform or enrich messages obtained at data sources 202. Moreover,because each rule may specify only a portion of the total transformationor enrichment of a message, rules may be created without knowledge ofthe entire transformation. For example, a first rule may be provided bya first system to transform a message according to the knowledge of thatsystem (e.g., transforming an error code into an error descriptor),while a second rule may process the message according to thetransformation (e.g., by detecting that the error descriptor satisfiesalert criteria). Thus, the streaming data processors 308 enable highlygranulized processing of data without requiring an individual entity(e.g., user or system) to have knowledge of all permutations ortransformations of the data.

After completion of the iterative processing loop 704, the interactionsof FIG. 7 proceed to interaction (9), where the intake ingestion buffer306 again determines subscribers of the message. The intake ingestionbuffer 306, at (10), the transmits the message to the streaming dataprocessors 308, and the streaming data processors 308 again analyze themessage for applicable rules, process the message according to therules, determine a target ingestion buffer and topic for the processedmessage, and acknowledge the message to the intake ingestion buffer 306,at interactions (11), (12), (13), and (15). These interactions aresimilar to interactions (4), (5), (6), and (8) discussed above, andtherefore will not be re-described. However, in contrast to interaction(13), the streaming data processors 308 may determine that a targetingestion buffer for the message is the output ingestion buffer 310.Thus, the streaming data processors 308, at (14), publishes the messageto the output ingestion buffer 310, making the data of the messageavailable to a downstream system.

FIG. 7 illustrates one processing path for data at the streaming dataprocessors 308. However, other processing paths may occur according toembodiments of the present disclosure. For example, in some instances, arule applicable to an initially published message on the intakeingestion buffer 306 may cause the streaming data processors 308 topublish the message out ingestion buffer 310 on first processing thedata of the message, without entering the iterative processing loop 704.Thus, interactions (2) through (8) may be omitted.

In other instances, a single message published to the intake ingestionbuffer 306 may spawn multiple processing paths at the streaming dataprocessors 308. Illustratively, the streaming data processors 308 may beconfigured to maintain a set of rules, and to independently apply to amessage all rules applicable to the message. Each application of a rulemay spawn an independent processing path, and potentially a new messagefor publication to a relevant ingestion buffer. In other instances, thestreaming data processors 308 may maintain a ranking of rules to beapplied to messages, and may be configured to process only a highestranked rule which applies to the message. Thus, a single message on theintake ingestion buffer 306 may result in a single message or multiplemessages published by the streaming data processors 308, according tothe configuration of the streaming data processors 308 in applyingrules.

As noted above, the rules applied by the streaming data processors 308may vary during operation of those processors 308. For example, therules may be updated as user queries are received (e.g., to identifymessages whose data is relevant to those queries). In some instances,rules of the streaming data processors 308 may be altered during theprocessing of a message, and thus the interactions of FIG. 7 may bealtered dynamically during operation of the streaming data processors308.

While the rules above are described as making various illustrativealterations to messages, various other alterations are possible withinthe present disclosure. For example, rules in some instances be used toremove data from messages, or to alter the structure of the messages toconform to the format requirements of a downstream system or component.Removal of information may be beneficial, for example, where themessages include private, personal, or confidential information which isunneeded or should not be made available by a downstream system. In someinstances, removal of information may include replacement of theinformation with a less confidential value. For example, a mailingaddress may be considered confidential information, whereas a postalcode may not be. Thus, a rule may be implemented at the streaming dataprocessors 308 to replace mailing addresses with a corresponding postalcode, to ensure confidentiality. Various other alterations will beapparent in view of the present disclosure.

4.1.4 Transmission to Subscribers

As discussed above, the rules applied by the streaming data processors308 may eventually cause a message containing data from a data source202 to be published to a topic on an output ingestion buffer 310, whichtopic may be specified, for example, by the rule applied by thestreaming data processors 308. The output ingestion buffer 310 maythereafter make the message available to downstream systems orcomponents. These downstream systems or components are generallyreferred to herein as “subscribers.” For example, the indexing system212 may subscribe to an indexing topic 342, the query system 214 maysubscribe to a search results topic 348, a client device 102 maysubscribe to a custom topic 352A, etc. In accordance with the pub-submodel, the output ingestion buffer 310 may transmit each messagepublished to a topic to each subscriber of that topic, and resilientlystore the messages until acknowledged by each subscriber (or potentiallyuntil an error is logged with respect to a subscriber). As noted above,other models of communication are possible and contemplated within thepresent disclosure. For example, rather than subscribing to a topic onthe output ingestion buffer 310 and allowing the output ingestion buffer310 to initiate transmission of messages to the subscriber 702, theoutput ingestion buffer 310 may be configured to allow a subscriber 702to query the buffer 310 for messages (e.g., unread messages, newmessages since last transmission, etc.), and to initiate transmission ofthose messages form the buffer 310 to the subscriber 702. In someinstances, such querying may remove the need for the subscriber 702 toseparately “subscribe” to the topic.

Accordingly, at (16), after receiving a message to a topic, the outputingestion buffer 310 determines the subscribers to the topic (e.g.,based on prior subscription requests transmitted to the output ingestionbuffer 310). At (17), the output ingestion buffer 310 transmits themessage to a subscriber 702. Thereafter, the subscriber may process themessage at (18). Illustrative examples of such processing are describedbelow, and may include (for example) preparation of search results for aclient device 204, indexing of the data at the indexing system 212, andthe like. After processing, the subscriber can acknowledge the messageto the output ingestion buffer 310, thus confirming that the message hasbeen processed at the subscriber.

4.1.5 Data Resiliency and Security

In accordance with embodiments of the present disclosure, theinteractions of FIG. 7 may be ordered such that resiliency is maintainedat the intake system 210. Specifically, as disclosed above, datastreaming systems (which may be used to implement ingestion buffers) mayimplement a variety of techniques to ensure the resiliency of messagesstored at such systems, absent systematic or catastrophic failures.Thus, the interactions of FIG. 7 may be ordered such that data from adata source 202 is expected or guaranteed to be included in at least onemessage on an ingestion system until confirmation is received that thedata is no longer required.

For example, as shown in FIG. 7, interaction (8)—wherein the streamingdata processors 308 acknowledges receipt of an initial message at theintake ingestion buffer 306—can illustratively occur after interaction(7)—wherein the streaming data processors 308 republishes the data tothe intake ingestion buffer 306. Similarly, interaction (15)—wherein thestreaming data processors 308 acknowledges receipt of an initial messageat the intake ingestion buffer 306—can illustratively occur afterinteraction (14)—wherein the streaming data processors 308 republishesthe data to the intake ingestion buffer 306. This ordering ofinteractions can ensure, for example, that the data being processed bythe streaming data processors 308 is, during that processing, alwaysstored at the ingestion buffer 306 in at least one message. Because aningestion buffer 306 can be configured to maintain and potentiallyresend messages until acknowledgement is received from each subscriber,this ordering of interactions can ensure that, should a device of thestreaming data processors 308 fail during processing, another deviceimplementing the streaming data processors 308 can later obtain the dataand continue the processing.

Similarly, as shown in FIG. 7, each subscriber 702 may be configured toacknowledge a message to the output ingestion buffer 310 afterprocessing for the message is completed. In this manner, should asubscriber 702 fail after receiving a message but prior to completingprocessing of the message, the processing of the subscriber 702 can berestarted to successfully process the message. Thus, the interactions ofFIG. 7 can maintain resiliency of data on the intake system 108commensurate with the resiliency provided by an individual ingestionbuffer 306.

While message acknowledgement is described herein as an illustrativemechanism to ensure data resiliency at an intake system 210, othermechanisms for ensuring data resiliency may additionally oralternatively be used.

As will be appreciated in view of the present disclosure, theconfiguration and operation of the intake system 210 can further providehigh amounts of security to the messages of that system. Illustratively,the intake ingestion buffer 306 or output ingestion buffer 310 maymaintain an authorization record indicating specific devices or systemswith authorization to publish or subscribe to a specific topic on theingestion buffer. As such, an ingestion buffer may ensure that onlyauthorized parties are able to access sensitive data. In some instances,this security may enable multiple entities to utilize the intake system210 to manage confidential information, with little or no risk of thatinformation being shared between the entities. The managing of data orprocessing for multiple entities is in some instances referred to as“multi-tenancy.”

Illustratively, a first entity may publish messages to a first topic onthe intake ingestion buffer 306, and the intake ingestion buffer 306 mayverify that any intake point or data source 202 publishing to that firsttopic be authorized by the first entity to do so. The streaming dataprocessors 308 may maintain rules specific to the first entity, whichthe first entity may illustrative provide through authenticated sessionon an interface (e.g., GUI, API, command line interface (CLI), etc.).The rules of the first entity may specify one or more entity-specifictopics on the output ingestion buffer 310 to which messages containingdata of the first entity should be published by the streaming dataprocessors 308. The output ingestion buffer 310 may maintainauthorization records for such entity-specific topics, thus restrictingmessages of those topics to parties authorized by the first entity. Inthis manner, data security for the first entity can be ensured acrossthe intake system 210. Similar operations may be performed for otherentities, thus allowing multiple entities to separately andconfidentially publish data to and retrieve data from the intake system.

4.1.6 Message Processing Algorithm

With reference to FIG. 8, an illustrative algorithm or routine forprocessing messages at the intake system 210 will be described in theform of a flowchart. The routine begins at block b102, where the intakesystem 210 obtains one or more rules for handling messages enqueued atan intake ingestion buffer 306. As noted above, the rules may, forexample, be human-generated, or may be automatically generated based onoperation of the data intake and query system 108 (e.g., in response touser submission of a query to the system 108).

At block 804, the intake system 210 obtains a message at the intakeingestion buffer 306. The message may be published to the intakeingestion buffer 306, for example, by the data retrieval subsystem 304(e.g., working in conjunction with a forwarder 302) and reflect dataobtained from a data source 202.

At block 806, the intake system 210 determines whether any obtained ruleapplies to the message. Illustratively, the intake system 210 (e.g., viathe streaming data processors 308) may apply selection criteria of eachrule to the message to determine whether the message satisfies theselection criteria. Thereafter, the routine varies according to whethera rule applies to the message. If no rule applies, the routine cancontinue to block 814, where the intake system 210 transmits anacknowledgement for the message to the intake ingestion buffer 306, thusenabling the buffer 306 to discard the message (e.g., once all othersubscribers have acknowledged the message). In some variations of theroutine, a “default rule” may be applied at the intake system 210, suchthat all messages are processed as least according to the default rule.The default rule may, for example, forward the message to an indexingtopic 342 for processing by an indexing system 212. In such aconfiguration, block 806 may always evaluate as true.

In the instance that at least one rule is determined to apply to themessage, the routine continues to block 808, where the intake system 210(e.g., via the streaming data processors 308) transforms the message asspecified by the applicable rule. For example, a processing sub-rule ofthe applicable rule may specify that data or metadata of the message beconverted from one format to another via an algorithmic transformation.As such, the intake system 210 may apply the algorithmic transformationto the data or metadata of the message at block 808 to transform thedata or metadata of the message. In some instances, no transformationmay be specified within intake system 210, and thus block 808 may beomitted.

At block 810, the intake system 210 determines a destination ingestionbuffer to which to publish the (potentially transformed) message, aswell as a topic to which the message should be published. Thedestination ingestion buffer and topic may be specified, for example, inprocessing sub-rules of the rule determined to apply to the message. Inone embodiment, the destination ingestion buffer and topic may varyaccording to the data or metadata of the message. In another embodiment,the destination ingestion buffer and topic may be fixed with respect toa particular rule.

At block 812, the intake system 210 publishes the (potentiallytransformed) message to the determined destination ingestion buffer andtopic. The determined destination ingestion buffer may be, for example,the intake ingestion buffer 306 or the output ingestion buffer 310.Thereafter, at block 814, the intake system 210 acknowledges the initialmessage on the intake ingestion buffer 306, thus enabling the intakeingestion buffer 306 to delete the message.

Thereafter, the routine returns to block 804, where the intake system210 continues to process messages from the intake ingestion buffer 306.Because the destination ingestion buffer determined during a priorimplementation of the routine may be the intake ingestion buffer 306,the routine may continue to process the same underlying data withinmultiple messages published on that buffer 306 (thus implementing aniterative processing loop with respect to that data). The routine maythen continue to be implemented during operation of the intake system210, such that data published to the intake ingestion buffer 306 isprocessed by the intake system 210 and made available on an outputingestion buffer 310 to downstream systems or components.

While the routine of FIG. 8 is described linearly, variousimplementations may involve concurrent or at least partially parallelprocessing. For example, in one embodiment, the intake system 210 isconfigured to process a message according to all rules determined toapply to that message. Thus for example if at block 806 five rules aredetermined to apply to the message, the intake system 210 may implementfive instances of blocks 808 through 814, each of which may transformthe message in different ways or publish the message to differentingestion buffers or topics. These five instances may be implemented inserial, parallel, or a combination thereof. Thus, the linear descriptionof FIG. 8 is intended simply for illustrative purposes.

While the routine of FIG. 8 is described with respect to a singlemessage, in some embodiments streaming data processors 308 may beconfigured to process multiple messages concurrently or as a batch.Similarly, all or a portion of the rules used by the streaming dataprocessors 308 may apply to sets or batches of messages. Illustratively,the streaming data processors 308 may obtain a batch of messages fromthe intake ingestion buffer 306 and process those messages according toa set of “batch” rules, whose criteria and/or processing sub-rules applyto the messages of the batch collectively. Such rules may, for example,determine aggregate attributes of the messages within the batch, sortmessages within the batch, group subsets of messages within the batch,and the like. In some instances, such rules may further alter messagesbased on aggregate attributes, sorting, or groupings. For example, arule may select the third messages within a batch, and perform aspecific operation on that message. As another example, a rule maydetermine how many messages within a batch are contained within aspecific group of messages. Various other examples for batch-based ruleswill be apparent in view of the present disclosure. Batches of messagesmay be determined based on a variety of criteria. For example, thestreaming data processors 308 may batch messages based on a thresholdnumber of messages (e.g., each thousand messages), based on timing(e.g., all messages received over a ten minute window), or based onother criteria (e.g., the lack of new messages posted to a topic withina threshold period of time).

4.2. Indexing

FIG. 9 is a data flow diagram illustrating an embodiment of the dataflow and communications between a variety of the components of the dataintake and query system 108 during indexing. Specifically, FIG. 9 is adata flow diagram illustrating an embodiment of the data flow andcommunications between an ingestion buffer 310, an ingest manager 406, apartition manager 408, a resource monitor 418, a resource catalog 420,an indexing node 404 or an indexer 410 or bucket manager 414, commonstorage 216, and/or a data store catalog 220. However, it will beunderstood, that in some of embodiments, one or more of the functionsdescribed herein with respect to FIG. 9 can be omitted, performed in adifferent order and/or performed by a different component of the dataintake and query system 108. Accordingly, the illustrated embodiment anddescription should not be construed as limiting.

At (1), the ingestion buffer 310 of the intake system 210 sends datarecords and buffer locations using one or more partitions to the ingestmanager 406. A buffer location can refer to the location in theingestion buffer 310 where a particular data record can be accessed. Insome embodiments, a data record can include data associated with aparticular tenant or a reference to a location (e.g. physical or logicaldirectory, file name, etc.) that stores the data associated with thetenant that is to be processed by the indexing system 212. In certainembodiments, the data record can also include a data identifier for thedata, such as a tenant identifier identifying the tenant to which thedata (either in the data record or at the location referenced by thedata record) is associated. The data in the data record or in thelocation referenced by the data record can include any one or anycombination of: raw machine data, structured data, unstructured data,performance metrics data, correlation data, data files, directories offiles, data sent over a network, event logs, registries, JSON blobs, XMLdata, data in a data model, report data, tabular data, messagespublished to streaming data sources, data exposed in an API, data in arelational database, sensor data, image data, or video data, etc.

In some embodiments, the ingestion buffer 310 can operate according to apub-sub messaging service. As such, the ingestion buffer 310 cancommunicate the data records of the one or more partitions to the ingestmanager 406, and also ensure that the data records of the partitions areavailable for additional reads until the ingestion buffer 310 receivesan acknowledgement from a partition manager 408 or an indexing node 404that the data can be removed. In some cases, the ingestion buffer 310can use one or more read pointers or location markers to track data thathas been communicated to the ingest manager 406 but that has not beenacknowledged for removal. Accordingly, based on the location markers,the ingestion buffer 310 can retain a portion of its data persistentlyuntil it receives confirmation that the data can be deleted or has beenstored in common storage 216. As the ingestion buffer 310 receivesacknowledgments, it can update the location markers. In some cases, theingestion buffer 310 can include at least one location marker for eachpartition. In this way, the ingestion buffer 310 can separately trackthe progress of the data reads in the different partitions.

In certain embodiments, the ingest manager 406 or partition managers 408can receive (and/or store) the location markers in addition to or aspart of the data records received from the ingestion buffer 310.Accordingly, the ingest manager 406 can track the location of the datain the ingestion buffer 310 that the ingest manager 406 has receivedfrom the ingestion buffer 310. In this way, if a partition manager 408becomes unavailable or fails, the ingest manager 406 can assign adifferent partition manager 408 to manage the data from the ingestionbuffer 310 and provide the partition manager 408 with a location fromwhich the partition manager 408 can obtain the data. Similarly, if anindexing node 404 becomes unavailable or fails, the partition manager408 or resource monitor 418 can assign a different indexing node 404 toprocess or manage data from the ingestion buffer 310 and provide theindexing node 404 with a location from which the indexing node 404 canobtain the data record from the ingestion buffer 310.

At (2), the ingest manager 406 activates a partition manager 408 for apartition. As described herein, the ingest manager 406 can receive datarecords from the ingestion buffer 310 across multiple partitions. Insome embodiments, the ingest manager 406 can activate (for example,generate or assign) a particular partition manager 408 for a particularpartition of the ingestion buffer 310. In this way, the particularpartition manager 408 receives the data records corresponding to theparticular partition of the ingestion buffer 310. In some cases, theingest manager 406 activates a different partition manager 408 for eachof the partitions of the ingestion buffer 310. In some cases, the ingestmanager 406 activates a partition manager 408 to manage data recordsfrom multiple partitions. In some embodiments, the ingest manager 406can activate a partition manager 408 based on the output of anadditional partition from the intake system 210, based on a partitionmanager 408 becoming unresponsive or unavailable, etc. In someembodiments, the partition manager 408 can be a copy of the ingestmanager 406 or a copy of a template process. In certain embodiments, thepartition manager 408 can be instantiated in a separate container fromthe ingest manager 406.

At (3), the resource monitor 418 monitors the indexing nodes 404 of theindexing system 212. As described herein, monitoring the indexing nodes404 can include requesting and/or receiving status information from theindexing nodes 404. In some embodiments, the resource monitor 418passively receives status information from the indexing nodes 404without explicitly requesting the information. For example, the indexingnodes 404 can be configured to periodically send status updates to theresource monitor. In certain embodiments, the resource monitor 418receives status information in response to requests made by the resourcemonitor 418. As described herein, the status information can include anyone or any combination of such as indexing node identifiers, metrics(e.g., CPU utilization, available memory), network architecture data, orindexing node assignments, etc.

At (4), the resource monitor 418 can use the information received fromthe indexing nodes 404 to update the resource catalog 420. As the statusof indexing nodes 404 change over time, the resource monitor 418 canupdate the resource catalog 420. In this way, the resource monitor 418can maintain the resource catalog 420 with information about theindexing nodes 404 of the indexing system 212.

It will be understood that (3) and (4) may be repeated togetherperiodically, according to a schedule, policy, or algorithm, such thatthe current (or reasonably current) availability, responsiveness, and/orutilization rate of the indexing nodes 404 and/or indexers 410 is storedin resource catalog 420. For example, a time-based schedule may be usedso that (3) and (4) may be performed every X number of seconds, or everyX minute(s), and so forth. The performance of (3) on a periodic basismay be referred to as a “heartbeat.”

At (5), a partition manager 408 assigned to distribute one or more datarecords from a partition of the ingestion buffer 310 to one or moreindexers 410 requests an indexing node assignment from the resourcemonitor 418 and/or resource catalog 420. In some cases, the partitionmanager 408 requests an indexing node assignment based on an indexingnode mapping policy. The indexing node mapping policy can use any one orany combination of data identifiers, time period, etc. to indicate howindexing nodes 404 should be assigned to process data records. In somecases, based on the indexing node mapping policy, the partition manager408 requests an indexing node assignment for each data record or for agroup of data records. For example, the partition manager 408 canrequest an indexing node assignment for some or all data recordsassociated with the same tenant identifier or other data identifier. Insome such cases, the partition manager 408 can include the dataidentifier associated with the data record(s) in its request for anindexing node assignment.

In certain cases, based on the indexing node mapping policy, thepartition manager 408 requests an indexing node assignment for aparticular amount of time, such as one minute, five minutes, etc. Insome embodiments, based on the indexing node mapping policy, thepartition manager 408 can request an indexing node assignment for datarecords based on a combination of data identifiers and time. Forexample, the partition manager can request an indexing node assignmentfor data records associated with the same tenant identifier for oneminute, five minutes, etc.

In certain embodiments, based on the indexing node mapping policy, thepartition manager 408 requests an indexing node identifier for theindexing node 404 that is to process a data record or group of datarecords. As described herein, the indexing node identifier can includean IP address, location address, or other identifier that can be used toidentify a particular indexing node that is to process the data recordor group of data records.

At (6) the resource monitor 418 identifies the indexing node assignmentbased on the indexing node mapping policy. As described herein, theindexing node mapping policy can use a variety of techniques to make anindexing node assignment. In some cases, the indexing node mappingpolicy can indicate that indexing node assignments are to be made basedon any one or any combination of: a data identifier associated with thedata record(s), availability of indexing nodes or other information fromthe resource catalog 420 such as indexing node identifiers associatedwith the indexing nodes 404, a hashing or consistent hashing scheme, atime period, etc.

In some embodiments, based on the indexing node policy, the resourcemonitor assigns one or a group of indexing nodes 404 to process datarecords with the same data identifier (e.g., tenant identifier). Incertain embodiments, based on the indexing node mapping policy, theresource monitor 418 assigns data records with the same data identifierto the same indexing node 404 (or group of indexing nodes 404) for aparticular time interval.

In some embodiments, based on the indexing node mapping policy, theresource monitor 418 identifies available indexing nodes using theinformation from the resource catalog 420 and assigns one of theavailable indexing nodes 404 to process the data record. As describedherein, the resource monitor 418 can identify an available indexing nodeusing various techniques. For example, the resource monitor 418 canconsult the resource catalog 420 to identify an available indexing node.

In certain embodiments, based on the indexing node mapping policy, theresource monitor 418 maps the data identifier to one or more indexingnodes 404 and then makes the indexing node assignment based on theavailability of the one or more indexing nodes 404. In some cases, theresource monitor 418 identifies available indexing nodes 404 and thenmaps the data identifier to one or more of the available indexing nodes404. In some embodiments, based on the indexing node mapping policy, theresource monitor 418 maps the data identifier to one or more indexingnodes 404 using a hash or consistent hash scheme. In certainembodiments, based on the indexing node mapping policy and for aparticular time interval, the resource monitor 418 identifies theindexing node assignment for data records associated with the sametenant using a consistent hash that maps the tenant identifier toindexing node identifiers on a hash ring.

In some cases, based on the indexing node mapping policy, a new indexingnode can be generated and assigned to process the data record. Forexample, if the resource monitor 418 determines that there areinsufficient indexing nodes 404 or that the indexing nodes are too busy(e.g., satisfy a utilization threshold), the resource monitor 418 canrequest that a new indexing node 404 be instantiated and assign thenewly instantiated indexing node 404 to process the data record.

At (7), the resource monitor 418 communicates the indexing nodeassignment to the partition manager 408. In some cases, the indexingnode assignment can include an identifier of the indexing node 404 thatis to process the data record. In certain embodiments, the indexing nodeassignment can include other information, such as a time interval forwhich the assignment is to last, a backup indexing node 404 in the eventthe assigned indexing node 404 is not available or fails, etc. Thepartition manager 408 can use the information from the indexing nodeassignment to communicate the data records to a particular indexingnode.

In some embodiments, (5), (6), and (7) can be omitted. For example,instead of requesting and receiving an indexing node assignment from theresource monitor 418, the partition manager 408 can consult an indexingnode assignment listing that identifies recent indexing nodeassignments. The indexing node assignment listing can include a table orlist of data identifiers and indexing nodes 404 that have processed, orare assigned to process, data associated with the data identifiers. Thetable or list can be stored as a lookup table or in a database, etc. Insome embodiments, if the partition manager 408 determines that anindexing node 404 is already assigned to process data associated withthe data identifier, the partition manager 408 can omit (5), (6), and(7), and send the data to the assigned indexing node 404 for processing.In certain embodiments, if the partition manager 408 determines that anindexing node 404 is not assigned to process data associated the dataidentifier, the partition manager 408 can proceed with steps (5), (6),and (7), and store the results of the indexing node assignment in theindexing node assignment listing.

In certain embodiments, indexing node assignments can be temporary. Forexample, indexing nodes 404 can be dynamically added or removed from theindexing system 212. Accordingly, to accommodate the change in indexingnodes 404, the indexing node assignments can be periodically redone. Tofacilitate the reassignment, the indexing node assignment listing can becleared or deleted periodically. For example, each 15, 30, 60, or 90seconds, the indexing node assignment listing can be cleared or removed.In certain embodiments, the indexing node assignment listing can includea timestamp indicating when a particular assignment was made. After apredetermined time period, the particular indexing node assignment canbe deleted. Accordingly, different entries of the indexing nodeassignment listing can change at different times.

In some cases, a different indexing node assignment listing can bestored on or associated with each different partition manager 408. Forexample, a particular partition manager 408 can manage its own indexingnode assignment listing by cataloging the indexing node assignmentsreceived from the resource monitor 418. As another example, the ingestmanager 406 can manage some or all of the indexing node assignmentlistings of its partition managers 408. In some cases, an indexing nodeassignment listing can be associated with some or all of the partitionmanagers 408. For example, the ingest manager 406 or the partitionmanagers 408 can manage the indexing node assignment listing bycataloging the indexing node assignments received from the resourcemonitor 418.

At (8), the ingest manager 406 tracks the buffer location and thepartition manager(s) 408 communicate the data to the indexer(s) 410. Asdescribed herein, the ingest manager 406 can track (and/or store) thebuffer location for the various partitions received from the ingestionbuffer 310. In addition, as described herein, the partition manager 408can forward the data received from the ingestion buffer 310 to theindexer(s) 410 for processing. In various implementations, as previouslydescribed, the data from ingestion buffer 310 that is sent to theindexer(s) 410 may include a path to stored data, e.g., data stored incommon storage 216 or another common storage, which is then retrieved bythe indexer 410 or another component of the indexing node 404.

As described herein, in some embodiments, the partition manager 408 cancommunicate different records to different indexing nodes 404. Forexample, the partition manager 408 can communicate records associatedwith one tenant (or one data identifier) to one indexing node 404 andrecords associated with another tenant (or another data identifier) toanother indexing node 404. Accordingly, the partition manager 408 canconcurrently distribute data associated with different tenants todifferent indexing nodes 404 for processing. In some cases, data recordsassociated with different tenants can be communicated to the sameindexing node 404 for processing. For example, based on the indexingnode mapping policy, the same indexing node 404 may be mapped to datafrom different tenants. As such, the partition manager 406 cancommunicate data from different tenants to the same indexing node 404.As a corollary, an indexing node 404 can receive and concurrentlyprocess data from different tenants.

At (9), the indexer 410 processes the data records. As described herein,in some cases, the data records include the data that is to be furtherprocessed by the indexing node 404. In some such embodiments, theindexing node 404 can process the data in the data records. In certainembodiments, the data records include a reference to the data that is tobe further processed by the indexing node 404. In some such embodiments,the indexing node 404 can access and process the data using thereference in the data record. As described herein, the indexer 410 canperform a variety of functions, enrichments, or transformations on thedata as it is indexed. For example, the indexer 410 can parse the data,identify events from the data, identify and associate timestamps withthe events, associate metadata or one or more field values with theevents, group events (e.g., based on time, partition, and/or tenant ID,etc.), etc. Furthermore, the indexer 410 can generate buckets based on abucket creation policy and store the events in the hot buckets, whichmay be stored in a data store 412 of the indexing node 404 associatedwith that indexer 410 (see FIGS. 4A and/or 4B). As described herein,when generating buckets, the indexer 410 can generate separate bucketsfor data associated with different tenants and/or indexes.

With reference to (1), (8), and (9), it will be understood that dataassociated with different data identifiers can be concurrently received,distributed, and/or processed by the same partition of the ingestionbuffer 310, the same partition manager 408 and/or the same indexer 410.Similarly, data associated with the same data identifier can beconcurrently received, distributed, and/or processed by differentpartitions of the ingestion buffer 310, different partition managers 408and/or different indexers 410.

With reference to (1), it will be understood that data recordsassociated with different identifiers can be found in the same partitionof the ingestion buffer 310 and that data records associated with thesame data identifier can be found across different partitions of theingestion buffer 310. For example, Partition 1 of ingestion buffer 310can include data from Tenant A and Tenant B, and Partition 2 can includedata from Tenant A and Tenant C.

With reference to (1) and (8), one partition manager 408 can receive anddistribute data associated with different data identifiers, anddifferent partition managers 408 can receive and distribute dataassociated with the same data identifier. With continued reference tothe example, Partition Manager 1 associated with Partition 1 can processand distribute data from Tenant A and Tenant B (the data from Partition1) and Partition Manager 2 association with Partition 2 can process anddistribute data from Tenant A and Tenant C (the data from Partition 2).

With reference to (9), indexing nodes 404 can receive and concurrentlyprocess data associated with the same data identifier from differentpartition managers 408 (or from the same partition manager 408) and dataassociated with different data identifiers from the same partitionmanager 408 (or from different partition managers 408). With continuedreference to the example above, based on an indexing node mappingpolicy, Indexer 1 can be assigned to receive and process Tenant A datafrom Partition Managers 1 and 2, and to receive and process Tenant Cdata from Partition Manager 2.

At (10), the indexer 410 copies and/or stores the data to common storage216. For example, the indexer 410 can determine (and/or the partitionmanager 408 can instruct the indexer 410) to copy the data to commonstorage 216 based on a bucket roll-over policy. The bucket roll-overpolicy can use any one or any combination of bucket size, data size,time period, etc. to determine that the data is to be copied to commonstorage 216.

In some cases, based on the bucket roll-over policy, the indexer 410periodically determines that the data is to be copied to common storage216. For example, the bucket roll-over policy may indicate a time-basedschedule so that the indexer 410 determines to copy and/or store thedata every X number of seconds, or every X minute(s), and so forth. Asanother example, the bucket roll-over policy may indicate that one ormore buckets are to be rolled over based on size. Accordingly, in someembodiments, the indexer 410 can determine to copy the data to commonstorage 216 based on a determination that the amount of data stored onthe indexer 410 satisfies a threshold amount. The threshold amount cancorrespond to the amount of data being processed by the indexer 410 forany partition or any tenant identifier. In some cases, the bucketroll-over policy may indicate that one or more buckets are to be rolledover based on a combination of a time-based schedule and size. Forexample, the bucket roll-over policy may indicate a time-based schedulein combination with a data threshold. For example, the indexer 410 candetermine to copy the data to common storage 216 based on adetermination that the amount of data stored on the indexer 410satisfies a threshold amount or a determination that the data has notbeen copied in X number of seconds, X number of minutes, etc.Accordingly, in some embodiments, the indexer 410 can determine that thedata is to be copied to common storage 216 without communication withthe partition manager 408 or the ingest manager 416.

In some cases, based on the bucket roll-over policy, the partitionmanager 408 can instruct the indexer 410 to copy the data to commonstorage 216. For example, the bucket roll-over policy may indicate thatone or more buckets are to be rolled over based on time and/or size. Insome such cases, the partition manager 408 can determine to instruct theindexer 410 to copy the data to common storage 216 based on adetermination that the amount of data stored on the indexer 410satisfies a threshold amount. The threshold amount can correspond to theamount of data associated with the partition that is managed by thepartition manager 408 or the amount of data being processed by theindexer 410 for any partition. For example, the indexer 410 can reportand/or the partition manager 408 can monitor the size of the data beingindexed to the partition manager 408 and/or the size of data beingprocessed by the indexer 410 for any partition or any tenant identifier.

In some such cases, the indexer 410 can report the size of the data inthe aggregate and/or the size of the data for each data identifier. Forexample, the indexer 410 can include the size of the data beingprocessed for one tenant and the size of the data being processed for adifferent tenant.

In some cases, the indexer 410 can routinely provide a status update tothe partition manager 408 regarding the data. The status update caninclude, but is not limited to the size of the data, the number ofbuckets being created, the amount of time since the buckets have beencreated, etc. In some embodiments, the indexer 410 can provide thestatus update based on one or more thresholds being satisfied (e.g., oneor more threshold sizes being satisfied by the amount of data beingprocessed, one or more timing thresholds being satisfied based on theamount of time the buckets have been created, one or more bucket numberthresholds based on the number of buckets created, the number of hot orwarm buckets, number of buckets that have not been stored in commonstorage 216, etc.).

In certain cases, the indexer 410 can provide an update to the partitionmanager 408 regarding the size of the data that is being processed bythe indexer 410 in response to one or more threshold sizes beingsatisfied. For example, each time a certain amount of data is added tothe indexer 410 (e.g., 5 MB, 10 MB, etc.), the indexer 410 can reportthe updated size to the partition manager 408. In some cases, theindexer 410 can report the size of the data stored thereon to thepartition manager 408 once a threshold size is satisfied.

In certain embodiments, the indexer 410 reports the size of the databeing indexed to the partition manager 408 based on a query by thepartition manager 408. In certain embodiments, the indexer 410 andpartition manager 408 maintain an open communication link such that thepartition manager 408 is persistently aware of the amount of data on theindexer 410.

In some cases, a partition manager 408 monitors the data processed bythe indexer 410. For example, the partition manager 408 can track thesize of the data on the indexer 410 that is associated with thepartition being managed by the partition manager 408. In certain cases,one or more partition managers 408 can track the amount or size of thedata on the indexer 410 that is associated with any partition beingmanaged by the ingest manager 406 or that is associated with theindexing node 404.

Any one or any combination of the aforementioned reporting or monitoringcan be done for different data or data associated with different dataidentifiers. For example, the indexers 410 can use one reporting schemefor data associated with one tenant and another reporting scheme fordata associated with a different tenant. Similarly, the indexers 410 canseparately report information for different data. Furthermore, thepartition manager 408 can monitor/track the data processed by theindexer 410 for different data identifiers.

In some cases, the partition manager 408 can instruct the indexer 410 tocopy the data that corresponds to the partition being managed by thepartition manager 408 to common storage 216 based on the size of thedata that corresponds to the partition satisfying the threshold amount.In certain embodiments, the partition manager 408 can instruct theindexer 410 to copy the data associated with any partition beingprocessed by the indexer 410 to common storage 216 based on the amountof the data from the partitions that are being processed by the indexer410 satisfying the threshold amount and/or an amount of time that haspassed since a bucket was stored to common storage 216, etc.

As described herein, the partition manager and/or indexer 410 can usedifferent bucket roll-over policies for buckets associated withdifferent data identifiers. For example, the indexer 410 can use onebucket roll-over policy (or thresholds) for buckets associated with onetenant and a bucket roll-over policy (or thresholds) for bucketsassociated with a different tenant. As such, an indexer 410 may copydata associated with one data identifier more or less frequently thandata associated with another identifier, or use different criteria todetermine when to copy data associated with the different dataidentifiers.

As part of storing the data to common storage 216, the indexer 410 canverify or obtain acknowledgements that the data is stored successfully.In some embodiments, the indexer 410 can determine information regardingthe data stored in the common storage 216. For example, the informationcan include location information regarding the data that was stored tothe common storage 216, bucket identifiers of the buckets that werecopied to common storage 216, as well as additional information, e.g.,in implementations in which the ingestion buffer 310 uses sequences ofrecords as the form for data storage, the list of record sequencenumbers that were used as part of those buckets that were copied tocommon storage 216.

When storing the data to common storage 216, the indexer 410 canphysically and/or logically separate data or buckets associated withdifferent data identifiers. For example, the indexer 410 can storebuckets associated with Tenant A in a separate directory, filestructure, or data store from buckets associated with Tenant B. In thisway, the indexer 410 can maintain the mutual exclusivity and/orindependence between data from different tenants. Similarly, the indexer410 can physically and/or logically separate data or buckets associatedwith different indexes of a tenant.

At (11), the indexer 410 reports or acknowledges to the partitionmanager 408 that the data is stored in the common storage 216. Invarious implementations, this can be in response to periodic requestsfrom the partition manager 408 to the indexer 410 regarding whichbuckets and/or data have been stored to common storage 216. The indexer410 can provide the partition manager 408 with information regarding thedata stored in common storage 216 similar to the data that is providedto the indexer 410 by the common storage 216. In some cases, (11) can bereplaced with the common storage 216 acknowledging or reporting thestorage of the data to the partition manager 408 and/or the indexer 410.

At (12), the indexer 410 updates the data store catalog 220. Asdescribed herein, the indexer 410 can update the data store catalog 220with information regarding the data or buckets stored in common storage216. For example, the indexer 410 can update the data store catalog 220to include location information, a bucket identifier, a time range, andtenant and partition information regarding the buckets copied to commonstorage 216, etc. In this way, the data store catalog 220 can includeup-to-date information regarding the buckets stored in common storage216.

At (13), the partition manager 408 reports the completion of the storageto the ingestion buffer 310 and/or another data store (for example,DynamoDB) that stores that stores the location marker information, andat (14), the ingestion buffer 310 updates the buffer location or markerand/or the another store updates it marker. Accordingly, in someembodiments, the ingestion buffer 310 and/or the another database systemcan maintain the location marker for a particular data record until theingestion buffer 310 (or other data store) receives an acknowledgementthat the data that the ingestion buffer 310 sent to the indexing node404 has been indexed by the indexing node 404 and stored to commonstorage 216. In addition, the updated buffer location or marker can becommunicated to and stored by the ingest manager 406. In this way, adata intake and query system 108 can use the ingestion buffer 310 toprovide a stateless environment for the indexing system 212. Forexample, as described herein, if an ingest manager 406, partitionmanager 408, indexing node 404 or one of its components (e.g., indexer410, data store 412, etc.) becomes unavailable or unresponsive beforedata from the ingestion buffer 310 is copied to common storage 216, theindexing system 212 can generate or assign a new component, to processthe data that was assigned to the now unavailable component whilereducing, minimizing, or eliminating data loss.

At (15), a bucket manager 414, which may form part of the indexer 410,the indexing node 404, or indexing system 212, merges multiple bucketsinto one or more merged buckets. As described herein, to reduce delaybetween processing data and making that data available for searching,the indexer 410 can convert smaller hot buckets to warm buckets and copythe warm buckets to common storage 216. However, as smaller buckets incommon storage 216 can result in increased overhead and storage costs,the bucket manager 414 can monitor warm buckets in the indexer 410 andmerge the warm buckets into one or more merged buckets.

In some cases, the bucket manager 414 can merge the buckets according toa bucket merge policy. As described herein, the bucket merge policy canindicate which buckets are candidates for a merge (e.g., based on timeranges, size, tenant, index, or other identifiers, etc.), the number ofbuckets to merge, size or time range parameters for the merged buckets,a frequency for creating the merged buckets, etc. It will be understoodthat the bucket manager 414 can use different bucket merge policies fordata associated with different data identifiers. For example, the bucketmanager 414 can merge buckets associated with one tenant using a firstbucket merge policy and buckets associated with a second tenant using asecond bucket merge policy.

At (16), the bucket manager 414 stores and/or copies the merged data orbuckets to common storage 216, and obtains information about the mergedbuckets stored in common storage 216. Similar to (7), the obtainedinformation can include information regarding the storage of the mergedbuckets, such as, but not limited to, the location of the buckets, oneor more bucket identifiers, tenant or partition identifiers, etc. At(17), the bucket manager 414 reports the storage of the merged data tothe partition manager 408, similar to the reporting of the data storageat (11).

At (18), the indexer 410 deletes data from the data store (e.g., datastore 412). As described herein, once the merged buckets have beenstored in common storage 216, the indexer 410 can delete correspondingbuckets that it has stored locally according to a bucket managementpolicy. For example, the indexer 410 can delete the merged buckets fromthe data store 412, as well as the pre-merged buckets (buckets used togenerate the merged buckets). By removing the data from the data store412, the indexer 410 can free up additional space for additional hotbuckets, warm buckets, and/or merged buckets.

At (19), the common storage 216 deletes data according to a bucketmanagement policy. As described herein, once the merged buckets havebeen stored in common storage 216, the common storage 216 can delete thepre-merged buckets stored therein. In some cases, as described herein,the common storage 216 can delete the pre-merged buckets immediately,after a predetermined amount of time, after one or more queries relyingon the pre-merged buckets have completed, or based on other criteria inthe bucket management policy, etc. In certain embodiments, a controllerat the common storage 216 handles the deletion of the data in commonstorage 216 according to the bucket management policy. In certainembodiments, one or more components of the indexing node 404 delete thedata from common storage 216 according to the bucket management policy.However, for simplicity, reference is made to common storage 216performing the deletion. As described herein, it will be understood thatdifferent bucket management policies can be used for data associatedwith different data identifiers. For example, the indexer 410 or commonstorage 216 can use one bucket management policy for buckets associatedwith one tenant and another bucket management policy for bucketsassociated with a different tenant.

At (20), the indexer 410 updates the data store catalog 220 with theinformation about the merged buckets. Similar to (12), the indexer 410can update the data store catalog 220 with the merged bucketinformation. The information can include, but is not limited to, thetime range of the merged buckets, location of the merged buckets incommon storage 216, a bucket identifier for the merged buckets, tenantand partition information of the merged buckets, etc. In addition, aspart of updating the data store catalog 220, the indexer 410 can removereference to the pre-merged buckets. Accordingly, the data store catalog220 can be revised to include information about the merged buckets andomit information about the pre-merged buckets. In this way, as thesearch managers 514 request information about buckets in common storage216 from the data store catalog 220, the data store catalog 220 canprovide the search managers 514 with the merged bucket information.

As mentioned previously, in some of embodiments, one or more of thefunctions described herein with respect to FIG. 8 can be omitted,performed in a variety of orders and/or performed by a differentcomponent of the data intake and query system 108. For example, theindexer 410 can (12) update the data store catalog 220 before, after, orconcurrently with the deletion of the data in the (18) indexer 410 or(19) common storage 216. Similarly, in certain embodiments, the indexer410 can (15) merge buckets before, after, or concurrently with(10)-(14), etc. As another example, the partition manager 408 canperform (12) and/or (14). In some cases, the indexer 410 can update thedata store catalog 220 before, after, or concurrently with (17)-(19),etc.

In some cases, (1)-(4) can be performed in any order, or concurrentlywith each other. For example, the ingest manager 416 can generate thepartition managers 408 before or after receiving data from the ingestionbuffer 310, while the resource monitor 418 concurrently monitors theindexers 410 and updates the resource catalog 420.

In certain embodiments, such as when an indexing system 212 isinstantiated for a single tenant, (3)-(7) may be omitted. For example,in some such embodiments, the indexing system 212 may not include aresource monitor 418 and/or resource catalog 420 and/or the indexingsystem 212 may have dedicated indexing nodes 404 for the tenant. In somesuch cases, the partition manager 408 can be configured to send the datato a particular indexer 410.

As another example, in some cases, the partition manager 408 may notrequest an indexer assignment from the resource monitor 418. In somesuch cases, the ingest manager 406 or partition manager 408 candetermine the indexer assignment. For example, the ingest manager 406 orpartition manager 408 can use an indexing node mapping policy toidentify an indexer 410 to process a particular data record. As anotherexample, the partition manager 408 may use an indexing node assignmentlisting to determine that a data record associated with a dataidentifier has already been assigned to a particular indexer 410. Insome such cases, the partition manager 408 can communicate the datarecord to the particular indexer 410 without requesting an indexerassignment from the resource monitor 418.

In some embodiments, the one or more components of the indexing system212 and/or the ingestion buffer 310 can concurrently process data frommultiple tenants. For example, each partition of the ingestion buffer310 can include data records associated with different tenants. In somecases, a data record can include data associated with one tenant anddifferent data records can include data from different tenants. Incertain cases, a data record can include location and/or identificationinformation of data or a file with data from a particular tenant and/ora tenant identifier corresponding to the particular tenant. For eachdata record, the partition manager 408 can request an indexing nodeassignment to process the data record, the resource monitor 418 canprovide an indexing node assignment for the data record, and theassigned indexing node 404 can process the data record (including anydata referenced by the data record). The ingest manager 406/partitionmanager 408, the resource monitor 418, and/or the indexer 410 canconcurrently process multiple data records in this manner. As differentdata records can be associated with different tenants, the ingestmanager 406 ingest manager 406/partition manager 408, the resourcemonitor 418, and/or the indexer 410 can concurrently process dataassociated with different tenants.

In certain embodiments, the components of the indexing system 212 mayonly process data from one tenant. For example, the ingestion buffer 310can be configured to only process data from one tenant. Correspondingly,the data records received and processed by the ingest manager406/partition manager 408 and/or indexer 410 can correspond to the sametenant. In some embodiments in which the components of the indexingsystem 212 only process data from one tenant, the resource monitor 418and/or resource catalog 420 (and corresponding (3), (4), (5), (6)) canbe omitted. In some such embodiments, the ingest manager 406/partitionmanager 408 may form part of an indexing node 404 as illustrated at FIG.4A and/or the data records from the partition manager 408 can be sent toone of a group of indexers 410 designated for the particular tenantusing a load balancing scheme. Further, in some embodiments in which thecomponents of the indexing system 212 only process data from one tenant,separate ingestion buffer(s) 310, ingest manager(s) 406/partitionmanager(s) 408, resource monitor(s) 418, resource catalog(s) 420,indexer(s) 410, and bucket manager(s) 414 can be instantiated for eachtenant.

4.2.1. Containerized Indexing Nodes

FIG. 10A is a flow diagram illustrative of an embodiment of a routineA1000 implemented by the indexing system 212 to store data in commonstorage 216. Although described as being implemented by the indexingsystem 212, it will be understood that the elements outlined for routineA1000 can be implemented by one or more computing devices/componentsthat are associated with the data intake and query system 108, such as,but not limited to, the indexing manager 402, the indexing node 404,ingest manager 406, the partition manager 408, the indexer 410, thebucket manager 414, etc. Thus, the following illustrative embodimentshould not be construed as limiting.

At block A1002, the indexing system 212 receives data. As describedherein, the system 312 can receive data from a variety of sources invarious formats. For example, as described herein, the data received canbe machine data, performance metrics, correlated data, etc.

At block A1004, the indexing system 212 stores the data in buckets usingone or more containerized indexing nodes 404. As described herein, theindexing system 212 can include multiple containerized indexing nodes404 to receive and process the data. The containerized indexing nodes404 can enable the indexing system 212 to provide a highly extensibleand dynamic indexing service. For example, based on resourceavailability and/or workload, the indexing system 212 can instantiateadditional containerized indexing nodes 404 or terminate containerizedindexing nodes 404. Further, multiple containerized indexing nodes 404can be instantiated on the same computing device, and share theresources of the computing device.

As described herein, each indexing node 404 can be implemented usingcontainerization or operating-system-level virtualization, or othervirtualization technique. For example, the indexing node 404, or one ormore components of the indexing node 404 can be implemented as separatecontainers or container instances. Each container instance can havecertain resources (e.g., memory, processor, etc.) of the underlyingcomputing system assigned to it, but may share the same operating systemand may use the operating system's system call interface. Further, eachcontainer may run the same or different computer applicationsconcurrently or separately, and may interact with each other. It will beunderstood that other virtualization techniques can be used. Forexample, the containerized indexing nodes 404 can be implemented usingvirtual machines using full virtualization or paravirtualization, etc.

In some embodiments, the indexing node 404 can be implemented as a groupof related containers or a pod, and the various components of theindexing node 404 can be implemented as related containers of a pod.Further, the indexing node 404 can assign different containers toexecute different tasks. For example, one container of a containerizedindexing node 404 can receive the incoming data and forward it to asecond container for processing, etc. The second container can generatebuckets for the data, store the data in buckets, and communicate thebuckets to common storage 216. A third container of the containerizedindexing node 404 can merge the buckets into merged buckets and storethe merged buckets in common storage. However, it will be understoodthat the containerized indexing node 404 can be implemented in a varietyof configurations. For example, in some cases, the containerizedindexing node 404 can be implemented as a single container and caninclude multiple processes to implement the tasks described above by thethree containers. Any combination of containerization and processed canbe used to implement the containerized indexing node 404 as desired.

In some embodiments, the containerized indexing node 404 processes thereceived data (or the data obtained using the received data) and storesit in buckets. As part of the processing, the containerized indexingnode 404 can determine information about the data (e.g., host, source,sourcetype), extract or identify timestamps, associated metadata fieldswith the data, extract keywords, transform the data, identify andorganize the data into events having raw machine data associated with atimestamp, etc. In some embodiments, the containerized indexing node 404uses one or more configuration files and/or extraction rules to extractinformation from the data or events.

In addition, as part of processing and storing the data, thecontainerized indexing node 404 can generate buckets for the dataaccording to a bucket creation policy. As described herein, thecontainerized indexing node 404 can concurrently generate and fillmultiple buckets with the data that it processes. In some embodiments,the containerized indexing node 404 generates buckets for each partitionor tenant associated with the data that is being processed. In certainembodiments, the indexing node 404 stores the data or events in thebuckets based on the identified timestamps.

Furthermore, containerized indexing node 404 can generate one or moreindexes associated with the buckets, such as, but not limited to, one ormore inverted indexes, TSIDXs, keyword indexes, etc. The data and theindexes can be stored in one or more files of the buckets. In addition,the indexing node 404 can generate additional files for the buckets,such as, but not limited to, one or more filter files, a bucket summary,or manifest, etc.

At block A1006, the indexing node 404 stores buckets in common storage216. As described herein, in certain embodiments, the indexing node 404stores the buckets in common storage 216 according to a bucket roll-overpolicy. In some cases, the buckets are stored in common storage 216 inone or more directories based on an index/partition or tenant associatedwith the buckets. Further, the buckets can be stored in a time seriesmanner to facilitate time series searching as described herein.Additionally, as described herein, the common storage 216 can replicatethe buckets across multiple tiers and data stores across one or moregeographical locations.

Fewer, more, or different blocks can be used as part of the routineA1000. In some cases, one or more blocks can be omitted. For example, insome embodiments, the containerized indexing node 404 or an indexingsystem manager 402 can monitor the amount of data received by theindexing system 212. Based on the amount of data received and/or aworkload or utilization of the containerized indexing node 404, theindexing system 212 can instantiate an additional containerized indexingnode 404 to process the data. In some embodiments, the blocks of routineA1000 can be combined with any one or any combination of blocksdescribed herein with reference to at least FIGS. 10B-10D, 12A-12G,15A-15G, and 16A.

In some cases, the containerized indexing node 404 can instantiate acontainer or process to manage the processing and storage of data froman additional shard or partition of data received from the intakesystem. For example, as described herein, the containerized indexingnode 404 can instantiate a partition manager 408 for each partition orshard of data that is processed by the containerized indexing node 404.

In certain embodiments, the indexing node 404 can delete locally storedbuckets. For example, once the buckets are stored in common storage 216,the indexing node 404 can delete the locally stored buckets. In thisway, the indexing node 404 can reduce the amount of data stored thereon.

As described herein, the indexing node 404 can merge buckets and storemerged buckets in the common storage 216. In some cases, as part ofmerging and storing buckets in common storage 216, the indexing node 404can delete locally storage pre-merged buckets (buckets used to generatethe merged buckets) and/or the merged buckets or can instruct the commonstorage 216 to delete the pre-merged buckets. In this way, the indexingnode 404 can reduce the amount of data stored in the indexing node 404and/or the amount of data stored in common storage 216.

In some embodiments, the indexing node 404 can update a data storecatalog 220 with information about pre-merged or merged buckets storedin common storage 216. As described herein, the information can identifythe location of the buckets in common storage 216 and other information,such as, but not limited to, a partition or tenant associated with thebucket, time range of the bucket, etc. As described herein, theinformation stored in the data store catalog 220 can be used by thequery system 214 to identify buckets to be searched as part of a query.

Furthermore, it will be understood that the various blocks describedherein with reference to FIG. 10 can be implemented in a variety oforders, or can be performed concurrently. For example, the indexing node404 can concurrently convert buckets and store them in common storage216, or concurrently receive data from a data source and process datafrom the data source, etc.

4.2.2. Moving Buckets to Common Storage

FIG. 10B is a flow diagram illustrative of an embodiment of a routineB1000 implemented by the indexing node 404 to store data in commonstorage 216. Although described as being implemented by the indexingnode 404, it will be understood that the elements outlined for routineB1000 can be implemented by one or more computing devices/componentsthat are associated with the data intake and query system 108, such as,but not limited to, the indexing manager 402, the ingest manager 406,the partition manager 408, the indexer 410, the bucket manager 414, etc.Thus, the following illustrative embodiment should not be construed aslimiting.

At block B1002, the indexing node 404 receives data. As describedherein, the indexing node 404 can receive data from a variety of sourcesin various formats. For example, as described herein, the data receivedcan be machine data, performance metrics, correlated data, etc.

Further, as described herein, the indexing node 404 can receive datafrom one or more components of the intake system 210 (e.g., theingesting buffer 310, forwarder 302, etc.) or other data sources 202. Insome embodiments, the indexing node 404 can receive data from a shard orpartition of the ingestion buffer 310. Further, in certain cases, theindexing node 404 can generate a partition manager 408 for each shard orpartition of a data stream. In some cases, the indexing node 404receives data from the ingestion buffer 310 that references or points todata stored in one or more data stores, such as a data store 218 ofcommon storage 216, or other network accessible data store or cloudstorage. In such embodiments, the indexing node 404 can obtain the datafrom the referenced data store using the information received from theingestion buffer 310.

At block B1004, the indexing node 404 stores data in buckets. In someembodiments, the indexing node 404 processes the received data (or thedata obtained using the received data) and stores it in buckets. As partof the processing, the indexing node 404 can determine information aboutthe data (e.g., host, source, sourcetype), extract or identifytimestamps, associated metadata fields with the data, extract keywords,transform the data, identify and organize the data into events havingraw machine data associated with a timestamp, etc. In some embodiments,the indexing node 404 uses one or more configuration files and/orextraction rules to extract information from the data or events.

In addition, as part of processing and storing the data, the indexingnode 404 can generate buckets for the data according to a bucketcreation policy. As described herein, the indexing node 404 canconcurrently generate and fill multiple buckets with the data that itprocesses. In some embodiments, the indexing node 404 generates bucketsfor each partition or tenant associated with the data that is beingprocessed. In certain embodiments, the indexing node 404 stores the dataor events in the buckets based on the identified timestamps.

Furthermore, indexing node 404 can generate one or more indexesassociated with the buckets, such as, but not limited to, one or moreinverted indexes, TSIDXs, keyword indexes, bloom filter files, etc. Thedata and the indexes can be stored in one or more files of the buckets.In addition, the indexing node 404 can generate additional files for thebuckets, such as, but not limited to, one or more filter files, abuckets summary, or manifest, etc.

At block B1006, the indexing node 404 monitors the buckets. As describedherein, the indexing node 404 can process significant amounts of dataacross a multitude of buckets, and can monitor the size or amount ofdata stored in individual buckets, groups of buckets or all the bucketsthat it is generating and filling. In certain embodiments, one componentof the indexing node 404 can monitor the buckets (e.g., partitionmanager 408), while another component fills the buckets (e.g., indexer410).

In some embodiments, as part of monitoring the buckets, the indexingnode 404 can compare the individual size of the buckets or thecollective size of multiple buckets with a threshold size. Once thethreshold size is satisfied, the indexing node 404 can determine thatthe buckets are to be stored in common storage 216. In certainembodiments, the indexing node 404 can monitor the amount of time thathas passed since the buckets have been stored in common storage 216.Based on a determination that a threshold amount of time has passed, theindexing node 404 can determine that the buckets are to be stored incommon storage 216. Further, it will be understood that the indexingnode 404 can use a bucket roll-over policy and/or a variety oftechniques to determine when to store buckets in common storage 216.

At block B1008, the indexing node 404 converts the buckets. In somecases, as part of preparing the buckets for storage in common storage216, the indexing node 404 can convert the buckets from editable bucketsto non-editable buckets. In some cases, the indexing node 404 converthot buckets to warm buckets based on the bucket roll-over policy. Thebucket roll-over policy can indicate that buckets are to be convertedfrom hot to warm buckets based on a predetermined period of time, one ormore buckets satisfying a threshold size, the number of hot buckets,etc. In some cases, based on the bucket roll-over policy, the indexingnode 404 converts hot buckets to warm buckets based on a collective sizeof multiple hot buckets satisfying a threshold size. The multiple hotbuckets can correspond to any one or any combination of randomlyselected hot buckets, hot buckets associated with a particular partitionor shard (or partition manager 408), hot buckets associated with aparticular tenant or partition, all hot buckets in the data store 412 orbeing processed by the indexer 410, etc.

At block B1010, the indexing node 404 stores the converted buckets in adata store. As described herein, the indexing node 404 can store thebuckets in common storage 216 or other location accessible to the querysystem 214. In some cases, the indexing node 404 stores a copy of thebuckets in common storage 216 and retains the original bucket in itsdata store 412. In certain embodiments, the indexing node 404 stores acopy of the buckets in common storage and deletes any reference to theoriginal buckets in its data store 412.

Furthermore, as described herein, in some cases, the indexing node 404can store the one or more buckets based on the bucket roll-over policy.In addition to indicating when buckets are to be converted from hotbuckets to warm buckets, the bucket roll-over policy can indicate whenbuckets are to be stored in common storage 216. In some cases, thebucket roll-over policy can use the same or different policies orthresholds to indicate when hot buckets are to be converted to warm andwhen buckets are to be stored in common storage 216.

In certain embodiments, the bucket roll-over policy can indicate thatbuckets are to be stored in common storage 216 based on a collectivesize of buckets satisfying a threshold size. As mentioned, the thresholdsize used to determine that the buckets are to be stored in commonstorage 216 can be the same as or different from the threshold size usedto determine that editable buckets should be converted to non-editablebuckets. Accordingly, in certain embodiments, based on a determinationthat the size of the one or more buckets have satisfied a thresholdsize, the indexing node 404 can convert the buckets to non-editablebuckets and store the buckets in common storage 216.

Other thresholds and/or other factors or combinations of thresholds andfactors can be used as part of the bucket roll-over policy. For example,the bucket roll-over policy can indicate that buckets are to be storedin common storage 216 based on the passage of a threshold amount oftime. As yet another example, bucket roll-over policy can indicate thatbuckets are to be stored in common storage 216 based on the number ofbuckets satisfying a threshold number.

It will be understood that the bucket roll-over policy can use a varietyof techniques or thresholds to indicate when to store the buckets incommon storage 216. For example, in some cases, the bucket roll-overpolicy can use any one or any combination of a threshold time period,threshold number of buckets, user information, tenant or partitioninformation, query frequency, amount of data being received, time of dayor schedules, etc., to indicate when buckets are to be stored in commonstorage 216 (and/or converted to non-editable buckets). In some cases,the bucket roll-over policy can use different priorities to determinehow to store the buckets, such as, but not limited to, minimizing orreducing time between processing and storage to common storage 216,maximizing or increasing individual bucket size, etc. Furthermore, thebucket roll-over policy can use dynamic thresholds to indicate whenbuckets are to be stored in common storage 216.

As mentioned, in some cases, based on an increased query frequency, thebucket roll-over policy can indicate that buckets are to be moved tocommon storage 216 more frequently by adjusting one more thresholds usedto determine when the buckets are to be stored to common storage 216(e.g., threshold size, threshold number, threshold time, etc.).

In addition, the bucket roll-over policy can indicate that differentsets of buckets are to be rolled-over differently or at different ratesor frequencies. For example, the bucket roll-over policy can indicatethat buckets associated with a first tenant or partition are to berolled over according to one policy and buckets associated with a secondtenant or partition are to be rolled over according to a differentpolicy. The different policies may indicate that the buckets associatedwith the first tenant or partition are to be stored more frequently tocommon storage 216 than the buckets associated with the second tenant orpartition. Accordingly, the bucket roll-over policy can use one set ofthresholds (e.g., threshold size, threshold number, and/or thresholdtime, etc.) to indicate when the buckets associated with the firsttenant or partition are to be stored in common storage 216 and adifferent set of thresholds for the buckets associated with the secondtenant or partition.

As another non-limiting example, consider a scenario in which bucketsfrom a partition_main are being queried more frequently than bucket fromthe partition_test. The bucket roll-over policy can indicate that basedon the increased frequency of queries for buckets from partition_main,buckets associated with partition_main should be moved more frequentlyto common storage 216, for example, by adjusting the threshold size usedto determine when to store the buckets in common storage 216. In thisway, the query system 214 can obtain relevant search results morequickly for data associated with the _main partition. Further, if thefrequency of queries for buckets from the _main partition decreases, thedata intake and query system 108 can adjust the threshold accordingly.In addition, the bucket roll-over policy may indicate that the changesare only for buckets associated with the partition_main or that thechanges are to be made for all buckets, or all buckets associated with aparticular tenant that is associated with the partition_main, etc.

Furthermore, as mentioned, the bucket roll-over policy can indicate thatbuckets are to be stored in common storage 216 at different rates orfrequencies based on time of day. For example, the data intake and querysystem 108 can adjust the thresholds so that the buckets are moved tocommon storage 216 more frequently during working hours and lessfrequently during non-working hours. In this way, the delay betweenprocessing and making the data available for searching during workinghours can be reduced, and can decrease the amount of merging performedon buckets generated during non-working hours. In other cases, the dataintake and query system 108 can adjust the thresholds so that thebuckets are moved to common storage 216 less frequently during workinghours and more frequently during non-working hours.

As mentioned, the bucket roll-over policy can indicate that based on anincreased rate at which data is received, buckets are to be moved tocommon storage more (or less) frequently. For example, if the bucketroll-over policy initially indicates that the buckets are to be storedevery millisecond, as the rate of data received by the indexing node 404increases, the amount of data received during each millisecond canincrease, resulting in more data waiting to be stored. As such, in somecases, the bucket roll-over policy can indicate that the buckets are tobe stored more frequently in common storage 216. Further, in some cases,such as when a collective bucket size threshold is used, an increasedrate at which data is received may overburden the indexing node 404 dueto the overhead associated with copying each bucket to common storage216. As such, in certain cases, the bucket roll-over policy can use alarger collective bucket size threshold to indicate that the buckets areto be stored in common storage 216. In this way, the bucket roll-overpolicy can reduce the ratio of overhead to data being stored.

Similarly, the bucket roll-over policy can indicate that certain usersare to be treated differently. For example, if a particular user islogged in, the bucket roll-over policy can indicate that the buckets inan indexing node 404 are to be moved to common storage 216 more or lessfrequently to accommodate the user's preferences, etc. Further, asmentioned, in some embodiments, the data intake and query system 108 mayindicate that only those buckets associated with the user (e.g., basedon tenant information, indexing information, user information, etc.) areto be stored more or less frequently.

Furthermore, the bucket roll-over policy can indicate whether, aftercopying buckets to common storage 216, the locally stored buckets are tobe retained or discarded. In some cases, the bucket roll-over policy canindicate that the buckets are to be retained for merging. In certaincases, the bucket roll-over policy can indicate that the buckets are tobe discarded.

Fewer, more, or different blocks can be used as part of the routineB1000. In some cases, one or more blocks can be omitted. For example, incertain embodiments, the indexing node 404 may not convert the bucketsbefore storing them. As another example, the routine B1000 can includenotifying the data source, such as the intake system, that the bucketshave been uploaded to common storage, merging buckets and uploadingmerged buckets to common storage, receiving identifying informationabout the buckets in common storage 216 and updating a data storecatalog 220 with the received information, etc. In some embodiments, theblocks of routine B1000 can be combined with any one or any combinationof blocks described herein with reference to at least FIGS. 10A,10C-10D, 12A-12G, 15A-15G, and 16A.

Furthermore, it will be understood that the various blocks describedherein with reference to FIG. 10B can be implemented in a variety oforders, or can be performed concurrently. For example, the indexing node404 can concurrently convert buckets and store them in common storage216, or concurrently receive data from a data source and process datafrom the data source, etc.

4.2.3. Updating Location Marker in Ingestion Buffer

FIG. 10C is a flow diagram illustrative of an embodiment of a routineC1000 implemented by the indexing node 404 to update a location markerin an ingestion buffer, e.g., ingestion buffer 310. Although describedas being implemented by the indexing node 404, it will be understoodthat the elements outlined for routine C1000 can be implemented by oneor more computing devices/components that are associated with the dataintake and query system 108, such as, but not limited to, the indexingmanager 402, the ingest manager 406, the partition manager 408, theindexer 410, the bucket manager 414, etc. Thus, the followingillustrative embodiment should not be construed as limiting. Moreover,although the example refers to updating a location marker in ingestionbuffer 310, other implementations can include other ingestion componentswith other types of location tracking that can be updated in a similarmanner as the location marker.

At block C1002, the indexing node 404 receives data. As described ingreater detail above with reference to block B1002, the indexing node404 can receive a variety of types of data from a variety of sources.

In some embodiments, the indexing node 404 receives data from aningestion buffer 310. As described herein, the ingestion buffer 310 canoperate according to a pub-sub messaging service. As such, the ingestionbuffer 310 can communicate data to the indexing node 404, and alsoensure that the data is available for additional reads until it receivesan acknowledgement from the indexing node 404 that the data can beremoved.

In some cases, the ingestion buffer 310 can use one or more readpointers or location markers to track the data that has beencommunicated to the indexing node 404 but that has not been acknowledgedfor removal. As the ingestion buffer 310 receives acknowledgments fromthe indexing node 404, it can update the location markers. In somecases, such as where the ingestion buffer 310 uses multiple partitionsor shards to provide the data to the indexing node 404, the ingestionbuffer 310 can include at least one location marker for each partitionor shard. In this way, the ingestion buffer 310 can separately track theprogress of the data reads in the different shards.

In certain embodiments, the indexing node 404 can receive (and/or store)the location markers in addition to or as part of the data received fromthe ingestion buffer 310. Accordingly, the indexing node 404 can trackthe location of the data in the ingestion buffer 310 that the indexingnode 404 has received from the ingestion buffer 310. In this way, if anindexer 410 or partition manager 408 becomes unavailable or fails, theindexing node 404 can assign a different indexer 410 or partitionmanager 408 to process or manage the data from the ingestion buffer 310and provide the indexer 410 or partition manager 408 with a locationfrom which the indexer 410 or partition manager 408 can obtain the data.

At block C1004, the indexing node 404 stores the data in buckets. Asdescribed in greater detail above with reference to block B1004 of FIG.10B, as part of storing the data in buckets, the indexing node 404 canparse the data, generate events, generate indexes of the data, compressthe data, etc. In some cases, the indexing node 404 can store the datain hot or warm buckets and/or convert hot buckets to warm buckets basedon the bucket roll-over policy.

At block C1006, the indexing node 404 stores buckets in common storage216. As described herein, in certain embodiments, the indexing node 404stores the buckets in common storage 216 according to the bucketroll-over policy. In some cases, the buckets are stored in commonstorage 216 in one or more directories based on an index/partition ortenant associated with the buckets. Further, the buckets can be storedin a time series manner to facilitate time series searching as describedherein. Additionally, as described herein, the common storage 216 canreplicate the buckets across multiple tiers and data stores across oneor more geographical locations. In some cases, in response to thestorage, the indexing node 404 receives an acknowledgement that the datawas stored. Further, the indexing node 404 can receive information aboutthe location of the data in common storage, one or more identifiers ofthe stored data, etc. The indexing node 404 can use this information toupdate the data store catalog 220.

At block C1008, the indexing node 404 notifies an ingestion buffer 310that the data has been stored in common storage 216. As describedherein, in some cases, the ingestion buffer 310 can retain locationmarkers for the data that it sends to the indexing node 404. Theingestion buffer 310 can use the location markers to indicate that thedata sent to the indexing node 404 is to be made persistently availableto the indexing system 212 until the ingestion buffer 310 receives anacknowledgement from the indexing node 404 that the data has been storedsuccessfully. In response to the acknowledgement, the ingestion buffer310 can update the location marker(s) and communicate the updatedlocation markers to the indexing node 404. The indexing node 404 canstore updated location markers for use in the event one or morecomponents of the indexing node 404 (e.g., partition manager 408,indexer 410) become unavailable or fail. In this way, the ingestionbuffer 310 and the location markers can aid in providing a statelessindexing service.

Fewer, more, or different blocks can be used as part of the routineC1000. In some cases, one or more blocks can be omitted. For example, incertain embodiments, the indexing node 404 can update the data storecatalog 220 with information about the buckets created by the indexingnode 404 and/or stored in common storage 216, as described herein. Insome embodiments, the blocks of routine C1000 can be combined with anyone or any combination of blocks described herein with reference to atleast FIGS. 10A, 10B, 10D, 12A-12G, 15A-15G, and 16A.

Furthermore, it will be understood that the various blocks describedherein with reference to FIG. 10C can be implemented in a variety oforders. In some cases, the indexing node 404 can implement some blocksconcurrently or change the order as desired. For example, the indexingnode 404 can concurrently receive data, store other data in buckets, andstore buckets in common storage.

4.2.4. Merging Buckets

FIG. 10D is a flow diagram illustrative of an embodiment of a routineD1000 implemented by the indexing node 404 to merge buckets. Althoughdescribed as being implemented by the indexing node 404, it will beunderstood that the elements outlined for routine D1000 can beimplemented by one or more computing devices/components that areassociated with the data intake and query system 108, such as, but notlimited to, the indexing manager 402, the ingest manager 406, thepartition manager 408, the indexer 410, the bucket manager 414, etc.Thus, the following illustrative embodiment should not be construed aslimiting.

At block D1002, the indexing node 404 stores data in buckets. Asdescribed herein, the indexing node 404 can process various types ofdata from a variety of sources. Further, the indexing node 404 cancreate one or more buckets according to a bucket creation policy andstore the data in the store the data in one or more buckets. Inaddition, in certain embodiments, the indexing node 404 can convert hotor editable buckets to warm or non-editable buckets according to abucket roll-over policy.

At block D1004, the indexing node 404 stores buckets in common storage216. As described herein, the indexing node 404 can store the buckets incommon storage 216 according to the bucket roll-over policy. In somecases, the buckets are stored in common storage 216 in one or moredirectories based on an index/partition or tenant associated with thebuckets. Further, the buckets can be stored in a time series manner tofacilitate time series searching as described herein. Additionally, asdescribed herein, the common storage 216 can replicate the bucketsacross multiple tiers and data stores across one or more geographicallocations.

At block D1006, the indexing node 404 updates the data store catalog220. As described herein, in some cases, in response to the storage, theindexing node 404 receives an acknowledgement that the data was stored.Further, the indexing node 404 can receive information about thelocation of the data in common storage, one or more identifiers of thestored data, etc. The received information can be used by the indexingnode 404 to update the data store catalog 220. In addition, the indexingnode 404 can provide the data store catalog 220 with any one or anycombination of the tenant or partition associated with the bucket, atime range of the events in the bucket, one or more metadata fields ofthe bucket (e.g., host, source, sourcetype, etc.), etc. In this way, thedata store catalog 220 can store up-to-date information about thebuckets in common storage 216. Further, this information can be used bythe query system 214 to identify relevant buckets for a query.

In some cases, the indexing node 404 can update the data store catalog220 before, after, or concurrently with storing the data to commonstorage 216. For example, as buckets are created by the indexing node404, the indexing node 404 can update the data store catalog 220 withinformation about the created buckets, such as, but not limited to, apartition or tenant associated with the bucket, a time range or initialtime (e.g., time of earliest-in-time timestamp), etc. In addition, theindexing node 404 can include an indication that the bucket is a hotbucket or editable bucket and that the contents of the bucket are not(yet) available for searching or in the common storage 216.

As the bucket is filled with events or data, the indexing node 404 canupdate the data store catalog 220 with additional information about thebucket (e.g., updated time range based on additional events, size of thebucket, number of events in the bucket, certain keywords or metadatafrom the bucket, such as, but not limited to a host, source, orsourcetype associated with different events in the bucket, etc.).Further, once the bucket is uploaded to common storage 216, the indexingnode 404 can complete the entry for the bucket, such as, by providing acompleted time range, location information of the bucket in commonstorage 216, completed keyword or metadata information as desired, etc.

The information in the data store catalog 220 can be used by the querysystem 214 to execute queries. In some cases, based on the informationin the data store catalog 220 about buckets that are not yet availablefor searching, the query system 214 can wait until the data is availablefor searching before completing the query or inform a user that somedata that may be relevant has not been processed or that the resultswill be updated. Further, in some cases, the query system 214 can informthe indexing system 212 about the bucket, and the indexing system 212can cause the indexing node 404 to store the bucket in common storage216 sooner than it otherwise would without the communication from thequery system 214.

In addition, the indexing node 404 can update the data store catalog 220with information about buckets to be merged. For example, once one ormore buckets are identified for merging, the indexing node 404 canupdate an entry for the buckets in the data store catalog 220 indicatingthat they are part of a merge operation and/or will be replaced. In somecases, as part of the identification, the data store catalog 220 canprovide information about the entries to the indexing node 404 formerging. As the entries may have summary information about the buckets,the indexing node 404 can use the summary information to generate amerged entry for the data store catalog 220 as opposed to generating thesummary information from the merged data itself. In this way, theinformation from the data store catalog 220 can increase the efficiencyof a merge operation by the indexing node 404.

At block D1008, the indexing node 404 merges buckets. In someembodiments, the indexing node 404 can merge buckets according to abucket merge policy. As described herein, the bucket merge policy canindicate which buckets to merge, when to merge buckets and one or moreparameters for the merged buckets (e.g., time range for the mergedbuckets, size of the merged buckets, etc.). For example, the bucketmerge policy can indicate that only buckets associated with the sametenant identifier and/or partition can be merged. As another example,the bucket merge policy can indicate that only buckets that satisfy athreshold age (e.g., have existed or been converted to warm buckets formore than a set period of time) are eligible for a merge. Similarly, thebucket merge policy can indicate that each merged bucket must be atleast 750 MB or no greater than 1 GB, or cannot have a time range thatexceeds a predetermined amount or is larger than 75% of other buckets.The other buckets can refer to one or more buckets in common storage 216or similar buckets (e.g., buckets associated with the same tenant,partition, host, source, or sourcetype, etc.). In certain cases, thebucket merge policy can indicate that buckets are to be merged based ona schedule (e.g., during non-working hours) or user login (e.g., when aparticular user is not logged in), etc. In certain embodiments, thebucket merge policy can indicate that bucket merges can be adjusteddynamically. For example, based on the rate of incoming data or queries,the bucket merge policy can indicate that buckets are to be merged moreor less frequently, etc. In some cases, the bucket merge policy canindicate that due to increased processing demands by other indexingnodes 404 or other components of an indexing node 404, such asprocessing and storing buckets, that bucket merges are to occur lessfrequently so that the computing resources used to merge buckets can beredirected to other tasks. It will be understood that a variety ofpriorities and policies can be used as part of the bucket merge policy.

At block D1010, the indexing node 404 stores the merged buckets incommon storage 216. In certain embodiments, the indexing node 404 canstore the merged buckets based on the bucket merge policy. For example,based on the bucket merge policy indicating that merged buckets are tosatisfy a size threshold, the indexing node 404 can store a mergedbucket once it satisfies the size threshold. Similarly, the indexingnode 404 can store the merged buckets after a predetermined amount oftime or during non-working hours, etc., per the bucket merge policy.

In response to the storage of the merged buckets in common storage 216,the indexing node 404 can receive an acknowledgement that the mergedbuckets have been stored. In some cases, the acknowledgement can includeinformation about the merged buckets, including, but not limited to, astorage location in common storage 216, identifier, etc.

At block D1012, the indexing node 404 updates the data store catalog220. As described herein, the indexing node 404 can store informationabout the merged buckets in the data store catalog. 220. The informationcan be similar to the information stored in the data store catalog 220for the pre-merged buckets (buckets used to create the merged buckets).For example, in some cases, the indexing node 404 can store any one orany combination of the following in the data store catalog: the tenantor partition associated with the merged buckets, a time range of themerged bucket, the location information of the merged bucket in commonstorage 216, metadata fields associated with the bucket (e.g., host,source, sourcetype), etc. As mentioned, the information about the mergedbuckets in the data store catalog 220 can be used by the query system214 to identify relevant buckets for a search. Accordingly, in someembodiments, the data store catalog 220 can be used in a similar fashionas an inverted index, and can include similar information (e.g., timeranges, field-value pairs, keyword pairs, location information, etc.).However, instead of providing information about individual events in abucket, the data store catalog 220 can provide information aboutindividual buckets in common storage 216.

In some cases, the indexing node 404 can retrieve information from thedata store catalog 220 about the pre-merged buckets and use thatinformation to generate information about the merged bucket(s) forstorage in the data store catalog 220. For example, the indexing node404 can use the time ranges of the pre-merged buckets to generate amerged time range, identify metadata fields associated with thedifferent events in the pre-merged buckets, etc. In certain embodiments,the indexing node 404 can generate the information about the mergedbuckets for the data store catalog 220 from the merged data itselfwithout retrieving information about the pre-merged buckets from thedata store catalog 220.

In certain embodiments, as part of updating the data store catalog 220with information about the merged buckets, the indexing node 404 candelete the information in the data store catalog 220 about thepre-merged buckets. For example, once the merged bucket is stored incommon storage 216, the merged bucket can be used for queries. As such,the information about the pre-merged buckets can be removed so that thequery system 214 does not use the pre-merged buckets to execute a query.

Fewer, more, or different blocks can be used as part of the routineD1000. In some cases, one or more blocks can be omitted. For example, incertain embodiments, the indexing node 404 can delete locally storedbuckets. In some cases, the indexing node 404 deletes any buckets usedto form merged buckets and/or the merged buckets. In this way, theindexing node 404 can reduce the amount of data stored in the indexingnode 404. In some embodiments, the blocks of routine D1000 can becombined with any one or any combination of blocks described herein withreference to at least FIGS. 10A-10C, 12A-12G, 15A-15G, and 16A.

In certain embodiments, the indexing node 404 can instruct the commonstorage 216 to delete buckets or delete the buckets in common storageaccording to a bucket management policy. For example, the indexing node404 can instruct the common storage 216 to delete any buckets used togenerate the merged buckets. Based on the bucket management policy, thecommon storage 216 can remove the buckets. As described herein, thebucket management policy can indicate when buckets are to be removedfrom common storage 216. For example, the bucket management policy canindicate that buckets are to be removed from common storage 216 after apredetermined amount of time, once any queries relying on the pre-mergedbuckets are completed, etc.

By removing buckets from common storage 216, the indexing node 404 canreduce the size or amount of data stored in common storage 216 andimprove search times. For example, in some cases, large buckets canincrease search times as there are fewer buckets for the query system214 to search. By another example, merging buckets after indexing allowsoptimal or near-optimal bucket sizes for search (e.g., performed byquery system 214) and index (e.g., performed by indexing system 212) tobe determined independently or near-independently.

Furthermore, it will be understood that the various blocks describedherein with reference to FIG. 10D can be implemented in a variety oforders. In some cases, the indexing node 404 can implement some blocksconcurrently or change the order as desired. For example, the indexingnode 404 can concurrently merge buckets while updating an ingestionbuffer 310 about the data stored in common storage 216 or updating thedata store catalog 220. As another example, the indexing node 404 candelete data about the pre-merged buckets locally and instruct the commonstorage 216 to delete the data about the pre-merged buckets whileconcurrently updating the data store catalog 220 about the mergedbuckets. In some embodiments, the indexing node 404 deletes thepre-merged bucket data entries in the data store catalog 220 prior toinstructing the common storage 216 to delete the buckets. In this way,the data indexing node 404 can reduce the risk that a query relies oninformation in the data store catalog 220 that does not reflect the datastored in the common storage 216.

4.2.5. Mapping Indexing Nodes

FIG. 10E is a flow diagram illustrative of an embodiment of a routineE1000 implemented by the resource monitor 418 to assign or map anindexing node 404 to process data. Although described as beingimplemented by the resource monitor 418, it will be understood that theelements outlined for routine E1000 can be implemented by one or morecomputing devices/components that are associated with the indexingsystem 212, such as, but not limited to, the resource catalog 420, theingest manager 406, the partition manager 408, the indexing systemmanager 402, the indexing node 404, the indexer 410, the bucket manager414, etc. Thus, the following illustrative embodiment should not beconstrued as limiting.

At block E1002, the resource monitor 418 maintains the resource catalog420. In some cases, the resource monitor 418 maintains the resourcecatalog 420 by communicating with some or all of the indexing nodes 404of the indexing system 212. For example, in some cases, each indexingnode 404 can include a monitoring module that can determine, identify,or track its own indexing node identifier, metrics, status identifiers,or network architecture relating to that indexing node 404. The resourcemonitor 418 can receive the information relating to the indexing nodes404 and use it to update and/or maintain the resource catalog 420. Incertain embodiments, the resource monitor 418 can communicate with themonitoring modules and receive information from which it can determinethe indexing node identifier, metrics, status identifiers, or networkarchitecture relating to that indexing node 404, and can use thatinformation to maintain the resource catalog 420.

In some cases, the resource monitor 418 communicates with the indexingnodes 404 by pinging them and receiving a response. For instance, theresource monitor 418 can ping the indexing nodes 404 at predeterminedintervals of time, such as every 1, 2, 5, 10, 30, or 60 seconds. Incertain embodiments, the indexing nodes 404 can be configured toautomatically send their data to the resource monitor 418. In somecases, the resource monitor 418 can determine that an indexing node 404is unavailable or failing based on the communications or absence ofcommunications from the indexing node 404, and can update the resourcecatalog 420 accordingly.

As described herein, the resource catalog 420 can include, among otherthings, information relating to the indexing nodes 404 of the indexingsystem 212. In some cases, the information relating to the indexingnodes 404 includes one or more indexing node identifiers. For example,as described herein, the indexing system 212 can include a plurality ofcontainerized indexing nodes 404 for parsing, processing, indexing,and/or storing data received from the intake system 210 via thepartition manager(s) 408. In some cases, the resource catalog 420 caninclude a different indexing node identifier for each indexing node 404of the indexing system 212. In some cases, for example if the indexingsystem 212 generates a new indexing node 404, the resource monitor 418can update the resource catalog 420 to include an indexing nodeidentifier associated with the new indexing node 404. In certain cases,if an indexing node 404 is removed from the indexing system 212 or theindexing node 404 becomes unresponsive or unavailable, the resourcemonitor 418 can update the resource catalog 420 to remove an indexingnode identifier associated with that indexing node 404. In this way, theresource catalog 420 can be consulted to determine which indexing nodes404 are instantiated in the indexing system 212.

In some cases, the information relating to the indexing nodes 404includes one or more metrics associated with one or more of the indexingnodes 404 in the indexing system 212. For example, the metrics caninclude, but are not limited to, one or more performance metrics such asCPU-related performance metrics (for example, a utilization rate of oneor more indexing nodes 404, an amount of processing resources in use byone or more indexing nodes 404, etc.), memory-related performancemetrics (for example, an amount of memory used by one or more indexingnodes 404), availability performance metrics (for example, whether anindexing node 404 is available), or the like.

In some cases, the information relating to the indexing nodes 404includes one or more status identifiers associated with one or more ofthe indexing nodes 404 in the indexing system 212. For example, in somecases, a status identifier associated with one or more of the indexingnodes 404 can include information relating to an availability of anindexing node. For example, the information relating to the indexingnodes 404 can include an indication of whether an indexing node 404 isavailable or unavailable. In some instances, as described herein, thisindication of availability can be based on a status update (or absenceof a status update) from the indexing node 404. In some instances, anindexing node 404 is considered available if it is instantiated in theindexing system 212 and/or is responsive communications from theresource monitor 418. In some cases, an indexing node 404 is consideredavailable if one or more metrics associated with the indexing node 404satisfies a metrics threshold. For example, an indexing node 404 canconsidered available if a utilization rate of the indexing node 404satisfies a utilization rate threshold. As another example, an indexingnode 404 can considered available if an amount of memory used by oravailable to the indexing node 404 satisfies a memory threshold. Asanother example, an indexing node 404 can be considered available if anamount of available processing resources of the indexing node 404satisfies a processing resources threshold.

In some cases, an indexing node 404 can be considered unavailable if oneor more, or some or all, metrics associated with the indexing node 404do not satisfy a metrics threshold. In some cases, as indexing nodes 404are instantiated (or at other times), the resource monitor 418 canupdate the resource catalog 420 with information about the indexing node404. Similarly, in some cases, as indexing nodes 404 are removed (or atother times), the resource monitor 418 can update the resource catalog420 with information about the indexing node 404 or can removeinformation about the indexing node 404.

In some cases, the information relating to the indexing nodes 404includes information relating to a network architecture associated withone or more of the indexing nodes 404 in the indexing system 212. Forexample, information relating to a network architecture can include anindication of when, where, or one what machine, an indexing node isinstantiated. As another example, information relating to a networkarchitecture can include an indication of a location of an indexing node404, for example with reference to other indexing nodes 404. As anotherexample, information relating to a network architecture can include anindication of computing resources shared with other indexing nodes 404,such as data stores, processors, I/O, etc.

In some cases, the information relating to the indexing nodes 404includes information relating to one or more indexing node assignments.As described herein, an indexing node assignment can include anindication of a mapping between a particular indexing node 404 and adata identifier (for example, a tenant identifier, a partition manageridentifier, etc.). In this way, an indexing node assignment can beutilized to determine to which indexing node 404 a partition manager 408should send data to process. For example, an indexing node assignmentcan indicate that a particular partition manager 408 should send itsdata to one or more particular indexing nodes 404. As another example,an indexing node assignment can indicate that some or all dataassociated with a particular data identifier (for example, dataassociated with a particular tenant identifier) should be forwarded toone or more particular indexing nodes 404 for processing. In some cases,the resource monitor 418 can determine an indexing node assignment andcan store the indexing node assignment in the resource catalog 420. Insome cases, the resource monitor 418 can determine an indexing nodeassignment, but it is not stored in the resource catalog 420. Forexample, each time the resource monitor 418 receives a request for anindexing node assignment from a partition manager 408, the resourcemonitor 418 can use information stored in the resource catalog 420 todetermine the indexing node assignment, but the indexing node assignmentmay not be stored in the resource catalog 420. In this way, the indexingnode assignments can be altered, for example if necessary based oninformation relating to the indexing nodes 404.

At block E1004, the resource monitor 418 receives a request for anindexing node 404 from a partition manager 408. As described herein, apartition manager 408 can receive a data record from a partition of theingestion buffer 310. In response, the partition manager 408 cantransmit the request for an indexing node assignment to the resourcemonitor 418 to determine to which indexing node(s) 404 the partitionmanager 408 should forward the data record for processing.

The request can include data which the resource monitor 418 can use todetermine an available and/or particular indexing node. For example, therequest can include a data identifier associated with the data record.As described herein, the data identifier can be a data sourceidentifier, tenant identifier, partition identifier, sourcetypeidentifier, or the like. In some cases, rather than or in addition toincluding an identifier in the request, the request can include areference to other data stored in a data store. For example, using thereference, the resource monitor 418 can obtain the other data and/oridentify (from the other data) the data identifier.

In addition, in some cases, the request includes a request for anindexing node identifier of the indexing node 404 to which the data isto be sent or a request for an indexing node assignment, which can beused to forward additional data records to the assigned indexing node404.

At block E1006, the resource monitor 418 identifies an indexing node 404to process the data record. As described herein, the resource monitor418 can use an indexing node mapping policy to identify the indexingnode 404. In some embodiments, based on the indexing node mappingpolicy, the resource monitor 418 identifies the indexing node 404 toprocess the data record based on a determined availability of anindexing node and a mapping of the data record to the indexing node 404.

In some embodiments, the resource monitor 418 first maps the data recordto an indexing node 404 and then determines whether the indexing node isavailable. In some such cases, the resource monitor 418 can map the datarecord to the indexing node 404 using a hashing algorithm. In certaincases, the resource monitor 418 uses a consistent hash or hash ring tomap the data identifier of the data record to an indexing nodeidentifier of an indexing node 404. For example, based on a hash of theindexing node identifiers of the indexing nodes 404, each indexing node404 can be placed on a hash ring. Similarly, based on a hash of the dataidentifier, the data identifier can also be placed on the hash ring.Based on the location of the data identifier on the hash ring, theresource monitor 418 can assign the data record to an indexing node 404.For example, the resource monitor 418 can assign the data record to theindexing node 404 whose hash value is closest to the hash value of thedata record or whose hash value is closest to the hash value of the datarecord when traveling in a particular direction around the hash ring.

If the mapped indexing node 404 is not available, the resource monitor418 can map the data record to another indexing node 404 until itidentifies an available indexing node. In certain cases, after mappingthe data record to an indexing node 404, if the resource monitor 418determines that the indexing node 404 is not available, the resourcemonitor 418 maps the data record to a second indexing node 404 bytraveling around a hash ring in a particular direction.

In certain embodiments, the resource monitor 418 first identifiesmultiple indexing nodes that are available to process the data recordand then maps the data record to one of the available indexing nodes 404using a hashing algorithm, such as a consistent hash as describedherein. In some cases, the resource monitor 418 identifies a singleindexing node 404 of the indexing system 212 that is available. In somesuch cases, the resource monitor 418 can assign the identified indexingnode to process the data record.

At block E1008, the resource monitor 418 communicates the indexing nodeassignment to the partition manager 408. In some embodiments, theindexing node assignment can include an indexing node identifierassociated with the indexing node 404 that is to process the datarecord. As described herein, the indexing node identifier can include anidentifier that the partition manager 408 can use to identify or locatethe data indexing node 404 that is to process the data record.

Fewer, more, or different blocks can be used as part of the routineE1000. In some cases, one or more blocks can be omitted. For example, insome cases, block E1004 can be omitted. In some such cases, the resourcemonitor 418 can communicate an indexing node assignment to one or morepartition managers 408 without receiving a request. For example, inaddition to the information about indexing nodes 404, the resourcemonitor 418 can include information regarding the data identifiers ofthe data to be distributed by the partition managers 408. In some suchembodiments, the resource monitor 418 can communicate the indexing nodeassignments to the partition managers 408 (or ingestion managers 406)that will be processing data with the different data identifiers beforereceiving a request. Accordingly, as the partition managers 408 receivedata associated with different data identifiers, they can use thealready-received indexing node assignments to distribute the datarecords to the indexing nodes 404. Further, the resource monitor 418 caninclude backup indexing node assignments such that if an indexing node404 is too busy or unresponsive, the partition manager 408 can send thedata to another indexing node 404.

In some embodiments, the resource monitor 418 can periodically updatethe indexing node assignments as described herein (non-limitingexamples: every 30 seconds, 60 seconds, 90 seconds, etc.). In some suchembodiments, each time the resource monitor 418 updates the indexingnode assignments, it can communicate the updated assignments to thepartition managers 408 (or ingestion manager 406). By providing thepartition managers 408 prior to a request, the resource monitor 418 canreduce communications between the partition managers 408 and theresource monitor 418 and/or reduce the delay in distributing datarecords at the partition managers 408.

In some embodiments, the resource monitor 418 can identify the dataidentifiers in order to generate the indexing node assignments byquerying the metadata catalog 221. For example, the resource monitor 418can obtain the tenant identifiers for the tenants using the indexingsystem 212 from the metadata catalog 221 and then map the tenantidentifiers to indexing node identifiers, and provide the mappings tothe partition managers 408. In this way, the partition managers 408 candistribute the data records to indexing nodes 404 without makingexplicit requests to the resource monitor 418.

In some cases, instead of sending the request to the resource monitor418, the partition manager 408 can consult an indexing node assignmentlisting that stores recent indexing node assignments. For example, thepartition manager 408 can consult the indexing node assignment listingto determine whether a data identifier associated with a particular datarecord already associated with to one or more indexing nodes 404. Insome cases, the indexing node assignment listing can include anindication of recent indexing node assignments, such as over a certainperiod of time, for example the last 15, 30, 60, or 90 seconds. In somecases, the indexing node assignment listing is cleared or deletedperiodically, such as every 15, 30, 60, or 90 seconds. In this way, thedatabase can store the most recent indexing node assignments. In somecases, if the indexing node assignment listing includes an indexing nodeassignment for the data identifier of the data record, the partitionmanager 408 can read the indexing node assignment and communicate thedata record to the associated indexing node 404.

It will be understood that the various blocks described herein withreference to FIG. 10E can be implemented in a variety of orders, or canbe performed concurrently. For example, the resource monitor 418 canconcurrently maintain the resource catalog 420, while receivingrequests, identifying the available indexing node, and/or communicatingwith the partition manager 408. Furthermore, it will be understood thatthe resource monitor 418 can concurrently process and respond torequests from different partition managers 408.

By maintaining the resource catalog 420 and dynamically assigningindexing nodes 404 to process data records, the data intake and querysystem 108 can be improved. For example, the resource catalog 420 canenable the data intake and query system 108 to more efficiently assignavailable indexing nodes 404 to process data records, which can improvethe throughput of the indexing system 212, increase resourceutilization, and decrease the amount of resources used.

Similarly, by dynamically assigning indexing nodes 404 to processrecords, the data intake and query system 108 can improve the throughputof the indexing system 212, increase resource utilization, and decreasethe amount of compute resources used or reserved. For example, if anindexing node 404 is underutilized, the data intake and query system 108can assign it to process incoming data rather than assigning anoverutilized indexing node 404 or generating an additional indexing node404. Further, by sharing indexing nodes between tenants, the data intakeand query system 108 can improve its resource utilization. For example,rather than having a set number of indexing nodes reserved for andunderutilized by a particular tenant, the data intake and query system108 can dynamically assign data from any tenant to any indexing node404.

In addition, by consistently assigning (or using an indexing nodemapping policy hat increases the likelihood of consistently assigning)indexing nodes 404 to process data from the same tenants, the dataintake and query system 108 can improve data throughput. For example, byconsistently assigning an indexing node 404 to process data from thesame tenant, the indexing system 212 can increase the size of thecreated buckets within a particular time frame and/or decrease theamount of time to fill a bucket. By increasing the size of a bucketwithin the time frame, the data intake and query system 108 can reducethe compute resources used to merge buckets. By reducing the amount oftime to fill a bucket, the data intake and query system can decrease thelag between receiving data, storing it to common storage 216, and makingit available for searching.

4.2.6. Processing Data from Multiple Partition Managers

FIG. 10F is a flow diagram illustrative of an embodiment of a routineE1000 implemented by indexing node 404 to process incoming data.Although described as being implemented by the indexing node 404, itwill be understood that the elements outlined for routine F1000 can beimplemented by one or more computing devices/components that areassociated with the indexing system 212, such as, but not limited to,the ingest manager 406, the partition manager 408, the indexing systemmanager 402, the indexer 410, the bucket manager 414, etc. Thus, thefollowing illustrative embodiment should not be construed as limiting.

At block F1002, an indexing node 404 receives first data associated witha first data identifier from a first partition manager 408. The firstdata can include one or more data records that the first partitionmanager 408 received from a partition of the ingestion buffer 310.

As described herein, an ingestion buffer 310 can communicate a datastream to one or more ingest managers 406 and/or partition managers 408using one or more partitions or shards. In some cases, a particularpartition manager 408 can be configured to receive data from one of thepartitions. In certain embodiments, the data received by the particularpartition manager 408 can include a sequence of data records to beprocessed by an indexer 410. Each data record can include data to befurther processed by an indexer 410 or a reference to data to be furtherprocessed by the indexer 410.

Based on an indexing node mapping policy, the first partition manager408 can distribute the data records to one or more indexing nodes404/indexers 410. In some implementations, each data record isassociated with a data identifier that corresponds to one or morecharacteristics of the data that is to be processed by the indexing node404. For example, the data identifier can include an indication of anorigin, contents, or a user associated with the data to be. As anotherexample, the data identifier can include a tenant identifier thatidentifies a particular tenant with which the data is associated, a datasource identifier that identifies a particular data source with whichthe data is associated, a sourcetype identifier that identifies aparticular sourcetype with which the data is associated, an indexidentifier that identifies a particular index with which the data isassociated, a host identifier that identifies a particular host withwhich the data is associated, a user identifier that identifies aparticular user with which the data is associated, etc. In someembodiments, based on the indexing node mapping policy, the partitionmanager 408 can assign data associated with the same data identifier tothe same indexing node 404 or to the same group of indexing nodes 404.

At block F1004, the indexing node 404 receives second data associatedwith the first data identifier from a second partition manager 408. Thesecond data can include one or more data records that the secondpartition manager 408 received from a second partition of the ingestionbuffer 310. In addition, similar to the first partition manager 408, thesecond partition manager 408 can assign the second data to the indexingnode 404 based on an indexing node mapping policy. In certainembodiments, the first and second partition managers 408 can use thesame indexing node mapping policy to assign data records to indexingnodes 404. As such, the indexing system 212 can assign data records toindexing nodes 404 in a uniform manner. In some embodiments, however,the indexing system 212 can use different indexing node assignmentpolicies to assign data records to indexing nodes 404. For example, theindexing system 212 may use one indexing node mapping policy to assigndata records associated with one data identifier (or received during onetime interval) and use another indexing node mapping policy to assigndata records associated with a different data identifier (or differenttime interval), etc.

In some cases, having the same data identifier indicates that the firstdata and the second data correspond to the same tenants, data sources,sourcetypes, hosts, users, indexes, partition managers, or the like.Accordingly, in some embodiments, the first and second partitionmanagers 408 can use the same indexing node mapping policy to assigndata with the same data identifier to the same indexing node 404.

In some implementations, the first partition is different from thesecond partition and/or the first partition manager 408 is differentfrom the second partition manager 408. Furthermore, in some cases, thefirst and second data are different types of data. For instance, thefirst data and the second data can be a different one of raw machinedata, structured data, unstructured data, performance metrics data,correlation data, data files, directories of files, data sent over anetwork, event logs, registries, JSON blobs, XML data, data in a datamodel, report data, tabular data, messages published to streaming datasources, data exposed in an API, data in a relational database, sensordata, image data, or video data.

At block F1006, the indexing node 404 processes the first and seconddata. In some cases, processing the first and second data can includeusing the first and second data to retrieve other data from a locationin a data store. In some embodiments, as described herein, the datarecords of the first data or second data distributed by the first andsecond partition managers 408 can include a reference to a location instorage where the indexing node 404 can retrieve data that can beprocessed into one or more events. In some such embodiments, theindexing node 404 can obtain the location references from the first andsecond data and use the location references retrieve data for furtherprocessing. In some cases, the referenced storage to which referencepointers point can correspond to the common storage 216 or other cloudor local storage. In some implementations, the data to which thereference pointers refer may be directed to common storage 216 fromintake system 210, e.g., streaming data processor 308 or ingestionbuffer 310.

In some cases, processing the first and second data can include, but isnot limited to, parsing, processing, indexing, or storing the first andsecond data (or the data referenced by the first and second data).Specifically, in some embodiments, the indexing node 404 can parse thedata to identify timestamps, generate events, group or save events intobuckets, generate summaries or indexes (e.g., time series index,inverted index, keyword index, etc.) of the events in the buckets,and/or store the buckets in common storage 216.

In some embodiments, an indexing node 404 can store events and bucketsgenerated from the first data and the second data (or data referenced bythe first data and the second data) in the data store 412 according to abucket creation policy, store the buckets in common storage 216according to a bucket roll-over policy, merge buckets according to abucket merge policy, and/or delete pre-merged buckets according a bucketmanagement policy, as described herein. In some such cases, the dataidentifier used to assign the first and second data to the same indexingnode 404 can be referred to as a primary data identifier, and other dataidentifiers (non-limiting example: index) that are (also) used to assignthe first and second data buckets can be referred to as secondary dataidentifiers. In some embodiments, different secondary data identifiersmay not affect whether the data corresponding to the first and seconddata is assigned to the same bucket (non-limiting examples: differentdata source identifiers or sourcetype identifiers). In certainembodiments, different secondary data identifiers can result in the databeing stored in different buckets (non-limiting examples: differentindexes).

In some cases, based on the bucket creation policy, the indexer 410generates at least one bucket for each tenant associated with the datathat it processes. In some embodiments the indexing node 404 storesevents generated based on the first and second data (e.g., eventsgenerated from the first and second data or events generated from thedata referenced by the first and second data) in the same bucket. Forexample, in addition to being associated with the same tenantidentifier, the first and second data may be associated with the sameindex (non-limiting example of a secondary data identifier) and timerange. As such, the indexing node 404 can generate a bucket that storessome of the first data and the second data.

In certain embodiments, the indexing node 404 stores events generatedfrom the first and second data in different buckets. For example,although the first and second data may both be associated with the sameprimary data identifier, the first and second data may be associatedwith different secondary data identifiers and/or time intervals. In somesuch embodiments, the indexing node 404 can generate one or more bucketsfor the first data and one or more distinct buckets for the second data.

As a non-limiting example consider a scenario in which the dataidentifiers for the first and second data correspond to the same tenant.For example, the first data can be associated with a first tenant (forexample, Tenant A) and first index (Index A) and received from a firstpartition (for example, Shard A), and the second data can be associatedwith the same tenant and index (Tenant A and Index A) and received froma different partition (for example, Shard B). In this example, theindexing node 404 a single bucket associated with Tenant A and Index Acan include at least some of the first data and at least some of thesecond data. Additional buckets may be generated for Tenant A based onthe amount of data received that is associated with Tenant A and/orsecondary data identifiers (non-limiting examples: different indexes).In this way, data that is associated with the same tenant can be storedin the same bucket(s). However, it will be understood that the indexingnode 404 can generate buckets in a variety of ways based on a bucketcreation policy.

Fewer, more, or different blocks can be used as part of the routineF1000. In some cases, one or more blocks can be omitted. In some cases,based on a bucket roll-over policy, once a particular bucket satisfies asize threshold, the indexing node 404 can store the bucket in or copythe bucket to common storage 216. In certain embodiments, based on abucket roll-over policy, a partition manager 408 can monitor the size ofthe buckets and instruct the indexing node 404 to copy the bucket tocommon storage 216. The threshold size can be predetermined ordynamically determined. As mentioned, in some cases different bucketroll-over policies can be used for data associated with different dataidentifiers.

Furthermore, in some cases, the ingest manager 416 or indexing node 404notifies an ingestion buffer 310 that the data has been stored in commonstorage 216. As described herein, in some cases, the ingestion buffer310 can retain location markers for the data that it sends to theindexing node 404. The ingestion buffer 310 can use the location markersto indicate that the data sent to the ingest manager 416 or indexingnode 404 is to be made persistently available to the indexing system 212until the ingestion buffer 310 receives an acknowledgement that the datahas been stored successfully. In response to the acknowledgement, theingestion buffer 310 can update the location marker(s) and communicatethe updated location markers to the ingest manager 416 or indexing node404. The ingest manager 416 or indexing node 404 can store updatedlocation markers for use in the event one or more components of theindexing node 404 become unavailable or fail. In this way, the ingestionbuffer 310 and the location markers can aid in providing a statelessindexing service. As described herein, in some cases, the locationmarkers retained until all data records up to that point have beenstored in common storage 216.

It will be understood that the various blocks described herein withreference to FIG. 10F can be implemented in a variety of orders, or canbe performed concurrently. For example, the indexing node 404 canconcurrently receive and process the first data and the second data.

By configuring an indexing node 404 to concurrently process data fromdifferent partition manager 408, the data intake and query system 108can be improved. In some cases, configuring indexing nodes 404 toconcurrently process data from different partition managers 408 canenable the data intake and query system 108 to independently scaleingest managers 406, partition managers 408, and indexing nodes 404. Forexample, one ingest manager 406 may be able to distribute data tomultiple indexing nodes 404 without satisfying a utilization threshold,affecting throughput, or generating an error. Accordingly, the dataintake and query system 108 can reduce the amount of compute resourcesreserved for ingest managers 406 or partition managers 408. In some suchcases, the compute resources that would have been reserved foradditional ingest mangers 406 or partition managers can be allocated foradditional indexing nodes 404 or indexers 410 in order to increase thethroughput of the system. As such, the data intake and query system 108can process more data using the same or fewer allocated computeresources.

4.2.7. Concurrently Processing Data with Different Data Identifiers

FIG. 10G is a flow diagram illustrative of an embodiment of a routineG1000 implemented by indexing node 404 to process incoming data.Although described as being implemented by the indexing node 404, itwill be understood that the elements outlined for routine F1000 can beimplemented by one or more computing devices/components that areassociated with the indexing system 212, such as, but not limited to,the resource monitor 418, the resource catalog 420, the ingest manager406, the partition manager 408, the indexing system manager 402, theindexer 410, the bucket manager 414, etc. Thus, the followingillustrative embodiment should not be construed as limiting.

At block G1002, an indexing node 404 receives first data associated witha first data identifier from a partition manager 408, as describedherein in greater detail at least with reference to block F1002 of FIG.10F. As described herein, the first data can include one or more datarecords that the partition manager 408 received from a partition of theingestion buffer 310. The data records can include data, or referencesto data, to be processed by one or more indexers 410 to generate one ormore events.

At block G1004, the indexing node 404 processes the first data. Similarto block F1006 of FIG. 10F, at block G1004, the indexing node 404processes the first data. In some cases, processing the first data caninclude using the first data to retrieve other data from a location in adata store. In some embodiments, as described herein, the data recordsof the first data distributed by the first partition manager 408 caninclude a reference to a location in storage where the indexing node 404can retrieve data that can be processed into one or more events. In somesuch embodiments, the indexing node 404 can obtain the locationreferences from the first data and use the location references retrievedata for further processing. In some cases, the referenced storage towhich reference pointers point can correspond to the common storage 216or other cloud or local storage. In some implementations, the data towhich the reference pointers refer may be directed to common storage 216from intake system 210, e.g., streaming data processor 308 or ingestionbuffer 310.

In some cases, processing the first data can include, but is not limitedto, parsing, processing, indexing, or storing the first data (or thedata referenced by the first data). Specifically, in some embodiments,the indexing node 404 can parse the data to identify timestamps,generate events, group or save events into buckets, generate summariesor indexes (e.g., time series index, inverted index, keyword index,etc.) of the events in the buckets, and/or store the buckets in commonstorage 216.

At block G1006, the indexing node 404 receives second data associatedwith a second data identifier from a partition manager 408. In someembodiments, the indexing node 404 receives the second data from thesame or different partition manager as the first data and/or the firstdata and the second data come from different partitions of the ingestionbuffer 310. Similar to the first data received at block G1002, thesecond data can include one or more data records that the partitionmanager 408 received from a partition of the ingestion buffer 310. Thedata records can include data, or references to data, to be processed byone or more indexers 410 to generate one or more events.

In some cases, the first data identifier and second data identifier aredifferent. For example, the first data and the second data cancorrespond to disparate tenants, data sources, sourcetypes, hosts,users, etc. As another example, the first data can be a different typeof data than the type of data of the second data. For example, the firstdata and the second data can be a different one of raw machine data,structured data, unstructured data, performance metrics data,correlation data, data files, directories of files, data sent over anetwork, event logs, registries, JSON blobs, XML data, data in a datamodel, report data, tabular data, messages published to streaming datasources, data exposed in an API, data in a relational database, sensordata, image data, or video data. However, it will be understood that, insome cases, the first data and the second data have the same or a commontenant, data source, sourcetype, host, user, or data type.

At block G1008, the indexing node 404 processes the second data. Similarto processing the first data as described herein with reference to blockG1006, processing the second data can include processing the second datato generate one or more events or using the second data to retrieveother data from a location in a data store and processing the retrieveddata to generate one or more events.

As a non-limiting example related to the embodiment of FIG. 10G00, thefirst and second data identifiers can correspond to different tenantsassociated with the first and second data, respectively. For example,the first data can be associated with a first tenant (for example,Tenant A), and the second data can be associated with a second tenant(for example, Tenant B), which may have come from the same or differentpartitions of the ingestion buffer 310. In this example, the indexingnode 404 can generate at least one bucket for each tenant so that abucket for Tenant A includes at least some of the first data and abucket for Tenant B includes at least some of the second data.Additional buckets may be generated for each tenant based on the amountof data received that is associated with the tenant. In this way, anindexing node 404 can process data from different tenants and canorganize buckets such that data that is associated with differenttenants can be stored in different buckets. Furthermore, the indexingnode 404 can store the data associated with different tenants indifferent directories or data stores such that the buckets associatedwith Tenant A are mutually exclusive or independent of the bucketsassociated with Tenant B. However, it will be understood that theindexing node 404 can generate buckets using a variety of policies. Forexample, the first and second data identifiers can correspond topartition, source, or sourcetype, of the first and second data, and theindexing node 404 can populate the bucket(s) based on partition, source,or sourcetype.

Fewer, more, or different blocks can be used as part of the routineG1000. In some cases, one or more blocks can be omitted. For example, insome embodiments, the indexing node 404 can store events and bucketsgenerated from the first data and the second data (or data referenced bythe first data and the second data) in the data store 412 according to abucket creation policy, store the buckets in common storage 216according to a bucket roll-over policy, merge buckets according to abucket merge policy, and/or delete pre-merged buckets according a bucketmanagement policy as described herein. In addition, the indexing node404 can use different policies for data associated with different dataidentifiers to create buckets, roll-over bucket, merge buckets and/ormanage buckets.

In some such cases, the data identifier used to assign the first andsecond data to the same indexing node 404 can be referred to as aprimary data identifier, and other data identifiers (non-limitingexample: index) that are (also) used to assign the first and second datato buckets can be referred to as secondary data identifiers. In someembodiments, even if secondary data identifiers are the same, if theprimary identifiers associated with data or data records being processedby the same indexing node are different, the indexing node can assignthe data to different buckets. Accordingly, in certain embodiments,first and second data can be assigned to the same bucket if the primarydata identifiers match and at least one secondary identifiers match andcan be assigned to different buckets if either the primary identifiersare different or if particular secondary identifiers are different(non-limiting examples: index identifier).

It will be understood that the various blocks described herein withreference to FIG. 10G can be implemented in a variety of orders, or canbe performed concurrently. For example, the indexing node 404 canconcurrently receive and process the first data and the second data.

By configuring an indexing node 404 to concurrently process data fromdifferent tenants, the data intake and query system 108 can be improved.In some cases, configuring indexing nodes 404 to concurrently processdata from different tenants can enable the data intake and query system108 to user fewer resources to process the same amount of data, improveresource utilization, etc. For example, instead of having a fixed numberof compute resource reserved to process each tenant, the data intake andquery system 108 can dynamically allocate resources to process data fromdifferent tenants. As such the data intake and query system 108 canscale in size in relation to the total amount of data being processed ormanaged rather than having a fixed number of reserved compute resources.Further, by scaling in relation to the total amount of being processedacross tenants, the data intake and query system 108 can improveresource utilization. For example, as resources satisfy utilizationthresholds, additional resources can be instantiated to process datafrom multiple tenants rather than being instantiated to process datafrom a single tenant. As another example, if a compute resource isunderutilized, the data intake and query system 108 can remove it.

4.3. Querying

FIG. 11 is a data flow diagram illustrating an embodiment of the dataflow and communications between a variety of the components of the dataintake and query system 108 in relation to a query. Specifically, FIG.11 is a data flow diagram illustrating an embodiment of the data flowand communications between the indexing system 212, the data storecatalog 220, metadata catalog 221, query system manager 502, searchhead(s) 504, resource monitor 508, resource catalog 510, search nodes506, common storage 216, and the query acceleration data store 222.However, it will be understood, that in some of embodiments, one or moreof the functions described herein with respect to FIG. 11 can beomitted, performed in a different order and/or performed by a differentcomponent of the data intake and query system 108. For example, in someembodiments, the steps identified as being performed by the query systemmanager 502 and search head 504 can be performed by the same component(e.g., the query system manager 502, the search head 504, or anothercomponent of the data intake and query system 108). In some suchembodiments, (6) can be omitted. Accordingly, the illustrated embodimentand description should not be construed as limiting.

Further, it will be understood that the various functions describedherein with respect to FIG. 11 can be performed by one or more distinctcomponents of the data intake and query system 108. For example, forsimplicity, reference is made to a search head 504 performing one ormore functions. However, it will be understood that these functions canbe performed by one or more components of the search head 504, such as,but not limited to, the search master 512 and/or the search manager 514.Similarly, reference is made to the indexing system 212 performing oneor more functions. However, it will be understood that the functionsidentified as being performed by the indexing system 212 can beperformed by one or more components of the indexing system 212.

At (1) and (2), the indexing system 212 monitors the storage ofprocessed data and updates the data store catalog 220 based on themonitoring. As described herein, one or more components of the indexingsystem 212, such as the partition manager 408 and/or the indexer 410 canmonitor the storage of data or buckets to common storage 216. As thedata is stored in common storage 216, the indexing system 212 can obtaininformation about the data stored in the common storage 216, such as,but not limited to, location information, bucket identifiers, tenantidentifier (e.g., for buckets that are single tenant) etc. The indexingsystem 212 can use the received information about the data stored incommon storage 216 to update the data store catalog 220.

Furthermore, as described herein, in some embodiments, the indexingsystem 212 can merge buckets into one or more merged buckets, store themerged buckets in common storage 216, and update the data store catalogto 220 with the information about the merged buckets stored in commonstorage 216.

At (3) and (4), the resource monitor 508 monitors some or all of thesearch heads 504 and search nodes 506 (in the query system 214),including the specific search head 504 and search nodes 506 used toexecute the query, and updates the resource catalog 510. As describedherein, the resource monitor 508 can monitor the availability,responsiveness, and/or utilization rate of the search heads 504 andsearch nodes 506. Based on the status of the search heads 504 and thesearch nodes 506, the resource monitor 508 can update the resourcecatalog 510. In this way, the resource catalog 510 can retaininformation regarding a current status of each of the search heads 504and the search nodes 506 in the query system 214. It will be understoodthat (3) and (4) may be repeated together periodically, according to aschedule, policy, or algorithm, such that the current (or reasonablycurrent) availability, responsiveness, and/or utilization rate of thesearch heads 504 and the search nodes 506 is stored in resource catalog510. For example, a time-based schedule may be used so that (3) and (4)may be performed every X number of seconds, or every X minute(s), and soforth. The performance of (3) on a periodic basis may be referred to asa “heartbeat.”

The monitoring of the search heads 504 and search nodes 506 may allowfor improved resource utilization through the implementation of dynamicresource scaling. Resource scaling can be performed by provisioningadditional search heads 504 and/or search nodes 506 (“spinning up”) ordecommissioning idle search heads 504 and/or search nodes 506 (“spinningdown”) based on various individual or aggregate capacity utilizationmetrics, such as CPU/memory utilization, the number of concurrentrunning searches, and so forth. For example, each search head 504 andeach search node 506 may periodically report (e.g., for a “heartbeat”)its status to the resource monitor 508, including information such asCPU/memory utilization and capacity, an indication of whether the searchhead is processing a search request (or if the search node is processingthe execution of a query), and so forth. Provisioning anddecommissioning resources can be performed based on applying analgorithm or a policy to the capacity utilization metrics. For instance,there may be different thresholds used for provisioning anddecommissioning resources. Thus, if many resources are being utilizedand a particular tenant requires more capacity than is available,additional resources can be spun up to meet that demand, or if not manyresources are being utilized, resources can be spun down to a minimumthreshold of idle computing.

In some embodiments one or more search heads 504, can be spun up orbased on search utilization. For instance, the current number ofconcurrently running searches may be known (e.g., from “heartbeats”received from the search heads). For instance, if based on the number ofsearch heads allocated 32 searches can be executed concurrently and only20 searches are being concurrently executed the query system 214 thatabout 60% of the search head capacity is being utilized. An upperthreshold can be set (e.g., above 80% capacity) and once that thresholdis satisfied, the number of search heads can be increased (e.g., by 5additional search heads). Once those new search heads are provisioned,they can start reporting (e.g., via “heartbeat”) to the resource monitor508 and the status of those search heads 504 can be tracked. Inembodiments in which information associated with a search request (e.g.,extraction rules, and so forth) are independently stored in a catalog(e.g., a metadata catalog 221) rather than passed as metadata associatedwith the search request to be locally stored on a search head, spinningup additional search heads 504, the query system 214 may be able to spinup a search head 504 relatively quickly given that configurationmanagement and synchronization between search heads 504 may not berequired and available search heads can be freely assigned to handle anysearch request associated with any tenant.

A lower threshold can also be set (e.g., below 20% capacity) and oncecapacity utilization decreases below the lower threshold, idle searchheads 504 or search nodes 506 can be decommissioned. In some cases,there may be a floor or minimum number of search heads that must beavailable at all times (e.g., 32 total search heads). For spinning downsearch heads 504, in some embodiments, the only requirement may be thata search head 504 must stop processing a search request before it can beremoved. In some embodiments, spinning up or down the number of searchheads 504 can be performed by the query system manager 502.

In the case of the search nodes 506, additional search nodes 506 may bespun up or spun down based on capacity utilization and/or based on thenumber of queries being executed. In some embodiments, a search node 506may be allocated to one query at a time. In some such embodiments, ifmore queries are requested than there are available search nodes or ifthe a threshold number of the total instantiated search nodes 506 are inuse, the query system 214 can instantiate an additional number of searchnodes 506.

In certain embodiments, such as where a search node 506 is concurrentlyassigned to multiple queries, spinning search nodes 506 up or down canbe based on capacity or resource utilization. For instance, the totalCPU/memory utilization and capacity across the search nodes 506 can bedetermined (e.g., by aggregating the individual CPU/memory utilizationand capacity for each search node). An upper threshold can be set (e.g.,above 80% utilization of total CPU/memory capacity) and once thatthreshold is exceeded, the number of search nodes can be increased(e.g., by 20 additional search nodes 506). Once the new search nodes 506are provisioned, they can start reporting (e.g., via “heartbeat”) to theresource monitor 508 and the status of those search nodes 506 can betracked. The new search nodes 506 can then available to be assigned to asearch head 504 (or search manager 514) to execute a query. As describedin greater detail herein, a variety of factors can be considered whenassigning search nodes 506.

A lower threshold can also be set (e.g., below 20% utilization of totalCPU/memory capacity) and once utilization drops below that lowerthreshold, certain search nodes may be decommissioned (e.g., searchnodes that were recently spun up). In some cases, there may be a set ofsearch nodes 506 that cannot be spun down first (e.g., the search nodeswith high cache hit ratio). In some embodiments, spinning up or down thenumber of search heads 504 can be performed by the query system manager502.

A search service (in some embodiments, the query system 214, search head504, query system manager 502, etc.) may receive a search request (e.g.,from a user associated with a tenant) and request an available searchhead 504 from the resource monitor 508 and/or resource catalog 510 forprocessing the search request.

At (5A), the resource monitor 508 can assign a search head 504 for thequery. In some embodiments, the resource monitor 508 can dynamicallyselect a search head 504 and assign it in response to the search requestbased on a search head mapping policy. For example, based on the searchhead mapping policy, the resource monitor 508 may identify a search head504 for the query based on a current availability, responsiveness,and/or utilization rate of the search heads 504 identified in theresource catalog 510. As described herein, the resource catalog 510 caninclude metrics like concurrent search count, CPU/memory capacity, andso forth. In some embodiments, based on the search head mapping policy,the research catalog 510 may be queried to identify an available searchhead 504 with free capacity for processing the search request.

There may be numerous benefits associated with dynamically (e.g., inresponse to a request) selecting and assigning, based on availabilityand utilization, the search head 504 for the search request, instead ofusing a pre-assigned search head 504 (e.g., to specific tenants).Pre-assigning resources to tenants (or based on data identifiers) mayresult in resource utilization issues, whereas dynamically assigningsearch heads 504 can improve resource utilization by allowing for theimplementation of dynamic resource scaling based on resourceutilization. In addition, dynamically assigning search heads 504 forqueries can enable a search head 504 to be shared across tenants,thereby reducing the amount of compute resources used by the data intakeand query system 108 and increase resource utilization. For instance,when pre-assigning resources, there may be various business orimplementation rationales which dictate a maximum amount of resourcesthat can be provided to any individual tenant, as well as a minimumamount of resources that must always be allocated for each tenant.However, some tenants may require more capacity than can be staticallyreserved or assigned to them. Similarly, some tenants may beoverprovisioned resources if they request fewer searches than expected.In such cases, their provisioned search heads 504 may sit idle. Incontrast, by dynamically assigning search heads 504 for incomingqueries, available search heads 504 can be used to process searchrequests from different tenants or process queries associated withdifferent data identifiers.

At (5B), the search head 504 receives the query and generates a searchmanager 514. In some embodiments, once the search head 504 is selected(non-limiting example: based on a search head mapping policy), the querycan be forwarded to it from the resource monitor 508 query systemmanager 502, etc. As described herein, in some cases, a search master512 can generate the search manager 514. For example, the search master512 can spin up or instantiate a new process, container, or virtualmachine, or copy itself to generate the search manager 514, etc. Asdescribed herein, in some embodiments, the search manager 514 canperform one or more of functions described herein with reference to FIG.11 as being performed by the search head 504 to process and execute thequery.

The search head 504 (6A) requests data identifiers from the data storecatalog 220. As described, the data store catalog 220 can includeinformation regarding the data stored in common storage 216.Accordingly, the search head 504 can query the data store catalog 220 toidentify data or buckets that include data that satisfies at least aportion of the query.

The search head 504 (6B) requests an identification of available searchnodes from the resource monitor 508 and/or resource catalog 510. Asdescribed herein, the resource catalog 510 can include informationregarding the search nodes 506 of the query system 214. The search head504 can either directly query the resource catalog 510 in order toidentify a number of search nodes available to execute the query, or thesearch head 504 may send a request to the resource monitor 508, whichwill identify a number of search nodes available to execute the query byconsulting the resource catalog 510. In some cases, the (6A) and (6B)requests can be done concurrently or in any order.

In some cases, the search head 504 requests a search node assignmentbased on a search node mapping policy. The search node mapping policycan use any one or any combination of data identifiers associated withthe query, search node identifiers, priority levels, etc. to indicatehow search nodes 506 should be assigned for a query. In some cases,based on the search node mapping policy, the search head 504 requests asearch node assignment for the query. In some such cases, the searchhead 504 can include the data identifier associated with the query inits request for a search node assignment.

At (7A), the data store catalog 220 provides the search head 504 with anidentification of data that satisfies at least a portion of the query.As described herein, in response to the request from the search head504, the data store catalog 220 can be used to identify and returnidentifiers of buckets in common storage 216 and/or location informationof data in common storage 216 that satisfy at least a portion of thequery or at least some filter criteria (e.g., buckets associated with anidentified tenant or partition or that satisfy an identified time range,etc.).

In some cases, as the data store catalog 220 can routinely receiveupdates by the indexing system 212, it can implement a read-write lockwhile it is being queried by the search head 504. Furthermore, the datastore catalog 220 can store information regarding which buckets wereidentified for the search. In this way, the data store catalog 220 canbe used by the indexing system 212 to determine which buckets in commonstorage 216 can be removed or deleted as part of a merge operation.

At (7B), the resource catalog 510 (or the resource monitor 508, byconsulting the resource catalog 510) provides the search head 504 with asearch node assignment and/or an identification of available searchnodes 506. As described herein, in response to the request from thesearch head 504, the resource catalog 510 and/or the resource monitor508 can be used to identify and return identifiers for search nodes 506that are available to execute the query. In some embodiments, theresource monitor 508 or resource catalog 510 determines the search nodeassignment based on a search node mapping policy, which can include asearch head-node mapping policy. As described herein, the search nodeassignment can be based on numerous factors, including the availabilityand utilization of each search node 506, a data identifier associatedwith the query, search node identifiers, etc.

There may be numerous benefits associated with dynamically (e.g., inresponse to a request) selecting and assigning the search nodes 506 forexecuting the query, in a manner that factors in availability andutilization rather than relying on pre-assigned search nodes (e.g., tospecific tenants). Pre-assigning resources to tenants may result inresource utilization issues, whereas dynamically assigning search nodes506 can improve resource utilization by allowing for the implementationof dynamic resource scaling based on resource utilization, as previouslymentioned, and also enabling search nodes to be shared across tenantsand allocated based on demand. For instance, when pre-assigningresources, there may be various business or implementation rationaleswhich dictate a maximum amount of resources that can be provided to anyindividual tenant, as well as a minimum amount of resources that mustalways be allocated for each tenant. However, some tenants may requiremore capacity than statically provided to them. Or, there may beoverprovisioning if some tenants do not request any searches, since thesearch nodes 506 assigned to those tenants may sit idle. In contrast,under dynamic assignment, search nodes 506 can be selected based onavailability and shared between tenants to execute queries.

As previously discussed, the search head-node mapping policy may alsoconsider additional factors beyond availability and utilization of thedifferent search nodes. For instance, the total number of search nodes506 being assigned to execute the query can vary and be determinedduring assignment of search nodes 506, such that the maximum number ofsearch nodes 506 being assigned is dynamic. The number of search nodes506 being assigned can be based on a static configuration, based on analgorithm run at the time the search nodes are being identified, and soforth. For instance, there may be a global static configuration (e.g.,always return X number of search nodes 506 in this scenario). Or theremay be a data identifier-specific static configuration (e.g., return atleast or no more than X number of search nodes 506 if the search requestis associated with tenant Y), such that the number of search nodes 506to assign to the search head 504 for executing the query may bepreconfigured based on the data identifier associated with the query(non-limiting example, a tenant identifier associated with the query).Alternatively, the number of search nodes 506 being assigned may bespecified in the query, either as an absolute number of search nodes(e.g., X number of search nodes), as a percentage of resources (e.g.,20% of the total number of search nodes or 20% of the number of searchnodes with sufficient capacity), and so forth. Thus, the resourcemonitor 508 and/or the resource catalog 510 may wait until there are asufficient number of search nodes 506 with availability that meets therequested number of search nodes 506 before assigning those search nodes506 to execute the query, or the resource monitor 508 and/or theresource catalog 510 may have additional search nodes 506 spun up tomeet the required number of search demands.

Furthermore, since data identifiers, such as tenant identifiers, aremapped to search nodes 506, similar queries for a specific tenant may beassociated with data stored in similar sets of buckets. In other words,some of the data for a specific tenant may reside in a local or shareddata store between search nodes 506 from an earlier query (e.g., thesearch nodes 506), and it may be desirable to assign additional queriesfor that tenant to those search nodes (e.g., the search nodes 506).Thus, the search head-node mapping policy may additionally attempt torepeatedly choose, for a specific tenant, the same search nodes 506 oras many of the same search nodes as possible that were used for previousqueries for that tenant in order to take advantage of caching. Forexample, if the query system 214 receives two queries associated with aspecific tenant and the same number of search nodes 506 are to be usedfor both queries, the same search nodes 506 can be assigned to the firstquery and the second query (either concurrently or consecutively).However, if the set of available search nodes 506 has changed betweenthe two queries, then the search head-node mapping policy may indicatethat a minimum amount of different search nodes 506 should be introducedfor the second query. This affinity for using the same search nodes 506can exist even when the search head 504 changes. For example, queriesassociated with the same data identifier can be assigned to variousdifferent search heads 504, but the same search nodes 506 or similarsearch nodes 506 (e.g., used in previous queries) can be used with thedifferent search heads 504.

As described herein, in some embodiments, using a consistent hashingalgorithm, the query system 214 can increase the likelihood that thesame search nodes 506 will be used to execute queries associated withthe same data identifiers. For example, as described herein, a hash canbe performed on a tenant identifier associated with the tenantrequesting the search, and the output of the hash can be used toidentify the search nodes 506 assigned to that tenant to use for thequery. In some implementations, the hash may be a consistent hash or usea hash ring, to increase the likelihood that the same search nodes 506are selected for the queries associated with the same data identifier.In some cases, the consistent hash function can be configured such thateven with a different number of search nodes 506 being assigned toexecute the query, the output can consistently identify some of the samesearch nodes 506 to execute the query, or have an increased probabilityof identifying some of the same search nodes 506 for the query.

In some embodiments, all the search nodes 506 may be mapped out tovarious different tenants (e.g., using tenant identifiers), such thateach search node 506 can be mapped to one or more specific tenants.Thus, in certain embodiments, a specific tenant can have a group of oneor more search nodes 506 assigned to it.

At (8) the search head 504 maps the identified search nodes 506 to thedata according to a search node mapping policy, which can include asearch node-data mapping policy. In some cases, per the search node-datamapping policy, the search head 504 can dynamically map search nodes 506to the identified data or buckets. As described herein, the search head504 can map the identified search nodes 506 to the identified data orbuckets at one time or iteratively as the buckets are searched accordingto the search node-data mapping policy. In certain embodiments, per thesearch node-data mapping policy, the search head 504 can map theidentified search nodes 506 to the identified data based on previousassignments, data stored in a local or shared data store of one or moresearch heads 504, network architecture of the search nodes 506, ahashing algorithm, etc.

In some cases, as some of the data may reside in a local or shared datastore between the search nodes 506, the search head 504 can attempt tomap that was previously assigned to a search node 506 to the same searchnode 506. In certain embodiments, to map the data to the search nodes506, the search head 504 uses the identifiers, such as bucketidentifiers, received from the data store catalog 220. In someembodiments, the search head 504 performs a hash function to map abucket identifier to a search node 506. In some cases, the search head504 uses a consistent hash algorithm, similar to a consistent hashingused to assign search nodes 506 to queries using a data identifier, toincrease the probability of mapping a bucket identifier to the samesearch node 506.

In certain embodiments, the search head 504 or query system 214 canmaintain a table or list of bucket mappings to search nodes 506. In suchembodiments, per the search node-data mapping policy, the search head504 can use the mapping to identify previous assignments between searchnodes and buckets. If a particular bucket identifier has not beenassigned to a search node 506, the search head 504 can use a hashalgorithm to assign it to a search node 506. In certain embodiments,prior to using the mapping for a particular bucket, the search head 504can confirm that the search node 506 that was previously assigned to theparticular bucket is available for the query. In some embodiments, ifthe search node 506 is not available for the query, the search head 504can determine whether another search node 506 that shares a data storewith the unavailable search node 506 is available for the query. If thesearch head 504 determines that an available search node 506 shares adata store with the unavailable search node 506, the search head 504 canassign the identified available search node 506 to the bucket identifierthat was previously assigned to the now unavailable search node 506.

At (9), the search head 504 instructs the search nodes 506 to executethe query. As described herein, based on the assignment of buckets tothe search nodes 506, the search head 504 can generate searchinstructions for each of the assigned search nodes 506. Theseinstructions can be in various forms, including, but not limited to,JSON, DAG, etc. In some cases, the search head 504 can generatesub-queries for the search nodes 506. Each sub-query or instructions fora particular search node 506 generated for the search nodes 506 canidentify any one or any combination of: the buckets that are to besearched, the filter criteria to identify a subset of the set of data tobe processed, and the manner of processing the subset of data, etc.Accordingly, the instructions can provide the search nodes 506 with therelevant information to execute their particular portion of the query.

At (10), the search nodes 506 obtain the data to be searched. Asdescribed herein, in some cases the data to be searched can be stored onone or more local or shared data stores of the search nodes 506. In someembodiments, the data to be searched is located in the intake system 210and/or the acceleration data store 222. In certain embodiments, the datato be searched is located in the common storage 216. In suchembodiments, the search nodes 506 or a cache manager 516 can obtain thedata from the common storage 216.

In some cases, the cache manager 516 can identify or obtain the datarequested by the search nodes 506. For example, if the requested data isstored on the local or shared data store of the search nodes 506, thecache manager 516 can identify the location of the data for the searchnodes 506. If the requested data is stored in common storage 216, thecache manager 516 can obtain the data from the common storage 216. Asanother example, if the requested data is stored in the intake system210 and/or the acceleration data store 222, the cache manager 516 canobtain the data from the intake system 210 and/or the acceleration datastore 222.

As described herein, in some embodiments, the cache manager 516 canobtain a subset of the files associated with the bucket to be searchedby the search nodes 506. For example, based on the query, the searchnode 506 can determine that a subset of the files of a bucket are to beused to execute the query. Accordingly, the search node 506 can requestthe subset of files, as opposed to all files of the bucket. The cachemanager 516 can download the subset of files from common storage 216 andprovide them to the search node 506 for searching.

In some embodiments, such as when a search node 506 cannot uniquelyidentify the file of a bucket to be searched, the cache manager 516 candownload a bucket summary or manifest that identifies the filesassociated with the bucket. The search node 506 can use the bucketsummary or manifest to uniquely identify the file to be used in thequery. The common storage 216 can then obtain that uniquely identifiedfile from common storage 216.

At (11), the search nodes 506 search and process the data. As describedherein, the sub-queries or instructions received from the search head504 can instruct the search nodes 506 to identify data within one ormore buckets and perform one or more transformations on the data.Accordingly, each search node 506 can identify a subset of the set ofdata to be processed and process the subset of data according to thereceived instructions. This can include searching the contents of one ormore inverted indexes of a bucket or the raw machine data or events of abucket, etc. In some embodiments, based on the query or sub-query, asearch node 506 can perform one or more transformations on the datareceived from each bucket or on aggregate data from the differentbuckets that are searched by the search node 506.

At (12), the search head 504 monitors the status of the query of thesearch nodes 506. As described herein, the search nodes 506 can becomeunresponsive or fail for a variety of reasons (e.g., network failure,error, high utilization rate, etc.). Accordingly, during execution ofthe query, the search head 504 can monitor the responsiveness andavailability of the search nodes 506. In some cases, this can be done bypinging or querying the search nodes 506, establishing a persistentcommunication link with the search nodes 506, or receiving statusupdates from the search nodes 506 (non-limiting example: the“heartbeat”). In some cases, the status can indicate the buckets thathave been searched by the search nodes 506, the number or percentage ofremaining buckets to be searched, the percentage of the query that hasbeen executed by the search node 506, etc. In some cases, based on adetermination that a search node 506 has become unresponsive, the searchhead 504 can assign a different search node 506 to complete the portionof the query assigned to the unresponsive search node 506.

In certain embodiments, depending on the status of the search nodes 506,the search manager 514 can dynamically assign or re-assign buckets tosearch nodes 506. For example, as search nodes 506 complete their searchof buckets assigned to them, the search manager 514 can assignadditional buckets for search. As yet another example, if one searchnode 506 is 95% complete with its search while another search node 506is less than 50% complete, the query manager can dynamically assignadditional buckets to the search node 506 that is 95% complete orre-assign buckets from the search node 506 that is less than 50%complete to the search node that is 95% complete. In this way, thesearch manager 514 can improve the efficiency of how a computing systemperforms searches through the search manager 514 increasingparallelization of searching and decreasing the search time.

At (13), the search nodes 506 send individual query results to thesearch head 504. As described herein, the search nodes 506 can send thequery results as they are obtained from the buckets and/or send theresults once they are completed by a search node 506. In someembodiments, as the search head 504 receives results from individualsearch nodes 506, it can track the progress of the query. For example,the search head 504 can track which buckets have been searched by thesearch nodes 506. Accordingly, in the event a search node 506 becomesunresponsive or fails, the search head 504 can assign a different searchnode 506 to complete the portion of the query assigned to theunresponsive search node 506. By tracking the buckets that have beensearched by the search nodes and instructing different search node 506to continue searching where the unresponsive search node 506 left off,the search head 504 can reduce the delay caused by a search node 506becoming unresponsive, and can aid in providing a stateless searchingservice.

At (14), the search head 504 processes the results from the search nodes506. As described herein, the search head 504 can perform one or moretransformations on the data received from the search nodes 506. Forexample, some queries can include transformations that cannot becompleted until the data is aggregated from the different search nodes506. In some embodiments, the search head 504 can perform thesetransformations.

At (15), the search head 504 stores results in the query accelerationdata store 222. As described herein, in some cases some, all, or a copyof the results of the query can be stored in the query acceleration datastore 222. The results stored in the query acceleration data store 222can be combined with other results already stored in the queryacceleration data store 222 and/or be combined with subsequent results.For example, in some cases, the query system 214 can receive ongoingqueries, or queries that do not have a predetermined end time. In suchcases, as the search head 504 receives a first set of results, it canstore the first set of results in the query acceleration data store 222.As subsequent results are received, the search head 504 can add them tothe first set of results, and so forth. In this way, rather thanexecuting the same or similar query data across increasingly larger timeranges, the query system 214 can execute the query across a first timerange and then aggregate the results of the query with the results ofthe query across the second time range. In this way, the query systemcan reduce the amount of queries and the size of queries being executedand can provide query results in a more time efficient manner.

At (16), the search head 504 terminates the search manager 514. Asdescribed herein, in some embodiments a search head 504 or a searchmaster 512 can generate a search manager 514 for each query assigned tothe search head 504. Accordingly, in some embodiments, upon completionof a search, the search head 504 or search master 512 can terminate thesearch manager 514. In certain embodiments, rather than terminating thesearch manager 514 upon completion of a query, the search head 504 canassign the search manager 514 to a new query.

As mentioned previously, in some of embodiments, one or more of thefunctions described herein with respect to FIG. 11 can be omitted,performed in a variety of orders and/or performed by a differentcomponent of the data intake and query system 108. For example, thesearch head 504 can monitor the status of the query throughout itsexecution by the search nodes 506 (e.g., during (10), (11), and (13)).Similarly, (1) and (2) can be performed concurrently, (3) and (4) can beperformed concurrently, and all can be performed before, after, orconcurrently with (5). Similarly, steps (6A) and (6B) and steps (7A) and(7B) can be performed before, after, or concurrently with each other.Further, (6A) and (7A) can be performed before, after, or concurrentlywith (7A) and (7B). As yet another example, (10), (11), and (13) can beperformed concurrently. For example, a search node 506 can concurrentlyreceive one or more files for one bucket, while searching the content ofone or more files of a second bucket and sending query results for athird bucket to the search head 504. Similarly, the search head 504 can(8) map search nodes 506 to buckets while concurrently (9) generatinginstructions for and instructing other search nodes 506 to beginexecution of the query. In some cases, such as when the set of data isfrom the intake system 210 or the acceleration data store 222, (6A) and(7A) can be omitted. Furthermore, in some such cases, the data may beobtained (10) from the intake system 210 and/or the acceleration datastore 222.

In some embodiments, such as when one or more search heads 504 and/orsearch nodes 506 are statically assigned to queries associated to atenant and/or with a particular data identifier, (3) and/or (5A) may beomitted. For example, in some such embodiments, there may only be onesearch head 504 associated with the data identifier or tenant. As such,the query system 214 may not dynamically assign a search head 504 forthe query. In certain embodiments, even where search heads 504 and/orsearch nodes 506 are statically assigned to a tenant or a dataidentifier, (3) and (5A) may be used to determine which of multiplesearch heads 504 assigned to the tenant or data identifier is to be usedfor the query, etc.

In certain embodiments, the query system can use multiple sub-policiesof a search node mapping policy to identify search nodes for a queryand/or to process data. For example, the query system 214 may use asearch head-node mapping policy to identify search nodes 506 to use inthe query and/or may use a search node-data policy to determine which ofthe assigned search nodes 506 is to be used to process certain data ofthe query. In some cases, the search node mapping policy may onlyinclude a search head-node mapping policy or a search node-data policyto identify search nodes 506 for the query, etc. Moreover, it will beunderstood that any one or any combination of the components of thequery system 214 can be used to implement a search node mapping policy.For example, the resource monitor 508 or search head 504 can implementthe search node mapping policy, or different portions of the search nodemapping policy, as desired.

4.3.1. Containerized Search Nodes

FIG. 12A is a flow diagram illustrative of an embodiment of a routineA1200 implemented by the query system 214 to execute a query. Althoughdescribed as being implemented by the search head 504, it will beunderstood that the elements outlined for routine A1200 can beimplemented by one or more computing devices/components that areassociated with the data intake and query system 108, such as, but notlimited to, the query system manager 502, the search head 504, thesearch master 512, the search manager 514, the search nodes 506, etc.Thus, the following illustrative embodiment should not be construed aslimiting.

At block A1202, the search manager 514 receives a query. As described ingreater detail above, the search manager 514 can receive the query fromthe search head 504, search master 512, etc. In some cases, the searchmanager 514 can receive the query from a client device 204. The querycan be in a query language as described in greater detail above. In somecases, the query received by the search manager 514 can correspond to aquery received and reviewed by the search head 504. For example, thesearch head 504 can determine whether the query was submitted by anauthenticated user and/or review the query to determine that it is in aproper format for the data intake and query system 108, has correctsemantics and syntax, etc. In some cases, the search head 504 can use asearch master 512 to receive search queries, and in some cases, spawnthe search manager 514 to process and execute the query.

At block A1204, the search manager 514 identifies one or morecontainerized search nodes, e.g., search nodes 506, to execute thequery. As described herein, the query system 214 can include multiplecontainerized search nodes 506 to execute queries. One or more of thecontainerized search nodes 506 can be instantiated on the same computingdevice, and share the resources of the computing device. In addition,the containerized search nodes 506 can enable the query system 214 toprovide a highly extensible and dynamic searching service. For example,based on resource availability and/or workload, the query system 214 caninstantiate additional containerized search nodes 506 or terminatecontainerized search nodes 506. Furthermore, the query system 214 candynamically assign containerized search nodes 506 to execute queries ondata in common storage 216 based on a search node-data mapping policy.

As described herein, each search node 506 can be implemented usingcontainerization or operating-system-level virtualization, or othervirtualization technique. For example, the containerized search node506, or one or more components of the search node 506 can be implementedas separate containers or container instances. Each container instancecan have certain resources (e.g., memory, processor, etc.) of theunderlying computing system assigned to it, but may share the sameoperating system and may use the operating system's system callinterface. Further, each container may run the same or differentcomputer applications concurrently or separately, and may interact witheach other. It will be understood that other virtualization techniquescan be used. For example, the containerized search nodes 506 can beimplemented using virtual machines using full virtualization orparavirtualization, etc.

In some embodiments, the search node 506 can be implemented as a groupof related containers or a pod, and the various components of the searchnode 506 can be implemented as related containers of a pod. Further, thesearch node 506 can assign different containers to execute differenttasks. For example one container of a containerized search node 506 canreceive and query instructions, a second container can obtain the dataor buckets to be searched, and a third container of the containerizedsearch node 506 can search the buckets and/or perform one or moretransformations on the data. However, it will be understood that thecontainerized search node 506 can be implemented in a variety ofconfigurations. For example, in some cases, the containerized searchnode 506 can be implemented as a single container and can includemultiple processes to implement the tasks described above by the threecontainers. Any combination of containerization and processed can beused to implement the containerized search node 506 as desired.

In some cases, the search manager 514 can identify the search nodes 506using the resource catalog 510. For example, as described herein aresource monitor 508 can monitor the status of the search nodes 506instantiated in the query system 214 and monitor their status. Theresource monitor can store the status of the search nodes 506 in theresource catalog 510.

In certain embodiments, the search manager 514 can identify search nodes506 using a search node-data mapping policy, previous mappings, previoussearches, or the contents of a data store associated with the searchnodes 506. For example, based on the previous assignment of a searchnode 506 to search data as part of a query, the search manager 514 canassign the search node 506 to search the same data for a differentquery. As another example, as search nodes 506 search data, it can cachethe data in a local or shared data store. Based on the data in thecache, the search manager 514 can assign the search node 506 to searchthe data again as part of a different query.

In certain embodiments, the search manager 514 can identify search nodes506 based on shared resources. For example, if the search manager 514determines that a search node 506 shares a data store with a search node506 that previously performed a search on data and cached the data inthe shared data store, the search manager 514 can assign the search node506 that share the data store to search the data stored therein as partof a different query.

In some embodiments, the search manager 514 can identify search nodes506 using a hashing algorithm. For example, as described herein, thesearch manager 514 based can perform a hash on a bucket identifier of abucket that is to be searched to identify a search node to search thebucket. In some implementations, that hash may be a consistent hash, toincrease the chance that the same search node will be selected to searchthat bucket as was previously used, thereby reducing the chance that thebucket must be retrieved from common storage 216.

It will be understood that the search manager 514 can identify searchnodes 506 based on any one or any combination of the aforementionedmethods. Furthermore, it will be understood that the search manager 514can identify search nodes 506 in a variety of ways.

At A1206, the search manager 514 instructs the search nodes 506 toexecute the query. As described herein, the search manager 514 canprocess the query to determine portions of the query that it willexecute and portions of the query to be executed by the search nodes506. Furthermore, the search manager 514 can generate instructions orsub-queries for each search node 506 that is to execute a portion of thequery. In some cases, the search manager 514 generates a DAG forexecution by the search nodes 506. The instructions or sub-queries canidentify the data or buckets to be searched by the search nodes 506. Inaddition, the instructions or sub-queries may identify one or moretransformations that the search nodes 506 are to perform on the data.

Fewer, more, or different blocks can be used as part of the routineA1200. In some cases, one or more blocks can be omitted. For example, incertain embodiments, the search manager 514 can receive partial resultsfrom the search nodes 506, process the partial results, perform one ormore transformation on the partial results or aggregated results, etc.Further, in some embodiments, the search manager 514 provide the resultsto a client device 204. In some embodiments, the search manager 514 cancombine the results with results stored in the accelerated data store222 or store the results in the accelerated data store 222 forcombination with additional search results. In some embodiments, theblocks of routine A1200 can be combined with any one or any combinationof blocks described herein with reference to at least FIGS. 10A-10D,12B-12G, 15A-15G, and 16A.

In some cases, the search manager 514 can identify the data or bucketsto be searched by, for example, using the data store catalog 220, andmap the buckets to the search nodes 506 according to a search node-datamapping policy. As described herein, the data store catalog 220 canreceive updates from the indexing system 212 about the data that isstored in common storage 216. The information in the data store catalog220 can include, but is not limited to, information about the locationof the buckets in common storage 216, and other information that can beused by the search manager 514 to identify buckets that include datathat satisfies at least a portion of the query.

In certain cases, as part of executing the query, the search nodes 506can obtain the data to be searched from common storage 216 using thecache manager 516. The obtained data can be stored on a local or shareddata store and searched as part of the query. In addition, the data canbe retained on the local or shared data store based on a bucket cachingpolicy as described herein.

Furthermore, it will be understood that the various blocks describedherein with reference to FIG. 12A can be implemented in a variety oforders. In some cases, the search manager 514 can implement some blocksconcurrently or change the order as desired. For example, the searchmanager 514 an concurrently identify search nodes 506 to execute thequery and instruct the search nodes 506 to execute the query. Asdescribed herein, in some embodiments, the search manager 514 caninstruct the search nodes 506 to execute the query at once. In certainembodiments, the search manager 514 can assign a first group of bucketsfor searching, and dynamically assign additional groups of buckets tosearch nodes 506 depending on which search nodes 506 complete theirsearching first or based on an updated status of the search nodes 506,etc.

4.3.2. Identifying Buckets and Search Nodes for Query

FIG. 12B is a flow diagram illustrative of an embodiment of a routineB1200 implemented by the query system 214 to execute a query. Althoughdescribed as being implemented by the search manager 514, it will beunderstood that the elements outlined for routine B1200 can beimplemented by one or more computing devices/components that areassociated with the data intake and query system 108, such as, but notlimited to, the query system manager 502, the search head 504, thesearch master 512, the search manager 514, the search nodes 506, etc.Thus, the following illustrative embodiment should not be construed aslimiting.

At block B1202, the search manager 514 receives a query, as described ingreater detail herein at least with reference to block A1202 of FIG.12A.

At block B1204, the search manager 514 identifies search nodes toexecute the query, as described in greater detail herein at least withreference to block A1204 of FIG. 12A. However, it will be noted, that incertain embodiments, the search nodes 506 may not be containerized.

At block B1206, the search manager 514 identifies buckets to query. Asdescribed herein, in some cases, the search manager 514 can consult thedata store catalog 220 to identify buckets to be searched. In certainembodiments, the search manager 514 can use metadata of the bucketsstored in common storage 216 to identify the buckets for the query. Forexample, the search manager 514 can compare a tenant identifier and/orpartition identifier associated with the query with the tenantidentifier and/or partition identifier of the buckets. The searchmanager 514 can exclude buckets that have a tenant identifier and/orpartition identifier that does not match the tenant identifier and/orpartition identifier associated with the query. Similarly, the searchmanager can compare a time range associate with the query with the timerange associated with the buckets in common storage 216. Based on thecomparison, the search manager 514 can identify buckets that satisfy thetime range associated with the query (e.g., at least partly overlap withthe time range from the query).

At B1208, the search manager 514 executes the query. As describedherein, at least with reference to A1206 of FIG. 12A, in someembodiments, as part of executing the query, the search manager 514 canprocess the search query, identify tasks for it to complete and tasksfor the search nodes 506, generate instructions or sub-queries for thesearch nodes 506 and instruct the search nodes 506 to execute the query.Further, the search manager 514 can aggregate the results from thesearch nodes 506 and perform one or more transformations on the data.

Fewer, more, or different blocks can be used as part of the routineB1200. In some cases, one or more blocks can be omitted. For example, asdescribed herein, the search manager 514 can map the search nodes 506 tocertain data or buckets for the search according to a search node-datamapping policy. Based on the search node-data mapping policy, the searchmanager 514 can instruct the search nodes to search the buckets to whichthey are mapped. Further, as described herein, in some cases, the searchnode-data mapping policy can indicate that the search manager 514 is touse a hashing algorithm, previous assignment, network architecture,cache information, etc., to map the search nodes 506 to the buckets. Insome embodiments, the blocks of routine B1200 can be combined with anyone or any combination of blocks described herein with reference to atleast FIGS. 10A-10D, 12A, 12C-12G, 15A-15G, and 16A.

As another example, the routine B1200 can include storing the searchresults in the accelerated data store 222. Furthermore, as describedherein, the search nodes 506 can store buckets from common storage 216to a local or shared data store for searching, etc.

In addition, it will be understood that the various blocks describedherein with reference to FIG. 12B can be implemented in a variety oforders, or implemented concurrently. For example, the search manager 514can identify search nodes to execute the query and identify bucket forthe query concurrently or in any order.

4.3.3. Identifying Buckets for Query Execution

FIG. 12C is a flow diagram illustrative of an embodiment of a routineC1200 implemented by the query system 214 to identify buckets for queryexecution. Although described as being implemented by the search manager514, it will be understood that the elements outlined for routine C1200can be implemented by one or more computing devices/components that areassociated with the data intake and query system 108, such as, but notlimited to, the query system manager 502, the search head 504, thesearch master 512, the search manager 514, the search nodes 506, etc.Thus, the following illustrative embodiment should not be construed aslimiting.

At block C1202, the data intake and query system 108 maintains a catalogof bucket in common storage 216. As described herein, the catalog canalso be referred to as the data store catalog 220, and can includeinformation about the buckets in common storage 216, such as, but notlimited to, location information, metadata fields, tenant and partitioninformation, time range information, etc. Further, the data storecatalog 220 can be kept up-to-date based on information received fromthe indexing system 212 as the indexing system 212 processes and storesdata in the common storage 216.

At block C1204, the search manager 514 receives a query, as described ingreater detail herein at least with reference to block A1202 of FIG.12A.

At block C1206, the search manager 514 identifies buckets to be searchedas part of the query using the data store catalog 220. As describedherein, the search manager 514 can use the data store catalog 220 tofilter the universe of buckets in the common storage 216 to buckets thatinclude data that satisfies at least a portion of the query. Forexample, if a query includes a time range of 4/23/18 from 03:30:50 to04:53:32, the search manager 514 can use the time range information inthe data store catalog to identify buckets with a time range thatoverlaps with the time range provided in the query. In addition, if thequery indicates that only a _main partition is to be searched, thesearch manager 514 can use the information in the data store catalog toidentify buckets that satisfy the time range and are associated with the_main partition. Accordingly, depending on the information in the queryand the information stored in the data store catalog 220 about thebuckets, the search manager 514 can reduce the number of buckets to besearched. In this way, the data store catalog 220 can reduce search timeand the processing resources used to execute a query.

At block C1208, the search manager 514 executes the query, as describedin greater detail herein at least with reference to block B1208 of FIG.12B.

Fewer, more, or different blocks can be used as part of the routineC1200. In some cases, one or more blocks can be omitted. For example, asdescribed herein, the search manager 514 can identify and map searchnodes 306 to the buckets for searching or store the search results inthe accelerated data store 222. In some embodiments, the blocks ofroutine C1200 can be combined with any one or any combination of blocksdescribed herein with reference to at least FIGS. 10A-10D, 12A, 12B,12D-12G, 15A-15G, and 16A. Furthermore, as described herein, the searchnodes 506 can store buckets from common storage 216 to a local or shareddata store for searching, etc. In addition, it will be understood thatthe various blocks described herein with reference to FIG. 12B can beimplemented in a variety of orders, or implemented concurrently.

4.3.4. Identifying Search Nodes for Query Execution

FIG. 12D is a flow diagram illustrative of an embodiment of a routineD1200 implemented by the query system 214 to identify search nodes forquery execution. Although described as being implemented by the searchmanager 514, it will be understood that the elements outlined forroutine D1200 can be implemented by one or more computingdevices/components that are associated with the data intake and querysystem 108, such as, but not limited to, the query system manager 502,the search head 504, the search master 512, the search manager 514, thesearch nodes 506, etc. Thus, the following illustrative embodimentshould not be construed as limiting.

At block D1202, the query system 214 maintains a catalog of instantiatedsearch nodes 506. As described herein, the catalog can also be referredto as the resource catalog 510, and can include information about thesearch nodes 506, such as, but not limited to, availability,utilization, responsiveness, network architecture, etc. Further, theresource catalog 510 can be kept up-to-date based on informationreceived by the resource monitor 508 from the search nodes 506.

At block D1204, the search manager 514 receives a query, as described ingreater detail herein at least with reference to block A1202 of FIG.12A. At block D1206, the search manager 514 identifies available searchnodes using the resource catalog 510, as described in greater detailherein at least with reference to block A1204 of FIG. 12A and blockB1204 of FIG. 12B.

At block D1208, the search manager 514 instructs the search nodes 506 toexecute the query, as described in greater detail herein at least withreference to block A1206 of FIG. 12A and block B1208 of FIG. 12B.

Fewer, more, or different blocks can be used as part of the routineD1200. In some cases, one or more blocks can be omitted. For example, incertain embodiments, the search manager can identify buckets in commonstorage 216 for searching. In some embodiments, the blocks of routineD1200 can be combined with any one or any combination of blocksdescribed herein with reference to at least FIGS. 10A-10D, 12A-12C,12E-12G, 15A-15G, and 16A. In addition, it will be understood that thevarious blocks described herein with reference to FIG. 12D can beimplemented in a variety of orders, or implemented concurrently.

4.3.5. Hashing Bucket Identifiers for Query Execution

FIG. 12E is a flow diagram illustrative of an embodiment of a routineE1200 implemented by the query system 214 to hash bucket identifiers forquery execution. Although described as being implemented by the searchmanager 514, it will be understood that the elements outlined forroutine E1200 can be implemented by one or more computingdevices/components that are associated with the data intake and querysystem 108, such as, but not limited to, the query system manager 502,the search head 504, the search master 512, the search manager 514, thesearch nodes 506, etc. Thus, the following illustrative embodimentshould not be construed as limiting.

At block E1202, the search manager 514 receives a query, as described ingreater detail herein at least with reference to block A1202 of FIG.12A.

At block E1204, the search manager 514 identifies bucket identifiersassociated with buckets to be searched as part of the query. The bucketidentifiers can correspond to an alphanumeric identifier or otheridentifier that can be used to uniquely identify the bucket from otherbuckets stored in common storage 216. In some embodiments, the uniqueidentifier may incorporate one or more portions of a tenant identifier,partition identifier, or time range of the bucket or a random orsequential (e.g., based on time of storage, creation, etc.) alphanumericstring, etc. As described herein, the search manager 514 can parse thequery to identify buckets to be searched. In some cases, the searchmanager 514 can identify buckets to be searched and an associated bucketidentifier based on metadata of the buckets and/or using a data storecatalog 220. However, it will be understood that the search manager 514can use a variety of techniques to identify buckets to be searched.

At block E1206, the search manager 514 performs a hash function on thebucket identifiers. The search manager can, in some embodiments, use theoutput of the hash function to identify a search node 506 to search thebucket. For example, as a non-limiting example, consider a scenario inwhich a bucket identifier is 4149 and the search manager 514 identifiedten search nodes to process the query. The search manager 514 couldperform a modulo ten operation on the bucket identifier to determinewhich search node 506 is to search the bucket. Based on this example,the search manager 514 would assign the ninth search node 506 to searchthe bucket, e.g., because the value 4149 modulo ten is 9, so the buckethaving the identifier 4149 is assigned to the ninth search node. In somecases, the search manager can use a consistent hash to increase thelikelihood that the same search node 506 is repeatedly assigned to thesame bucket for searching. In this way, the search manager 514 canincrease the likelihood that the bucket to be searched is alreadylocated in a local or shared data store of the search node 506, andreduce the likelihood that the bucket will be downloaded from commonstorage 216. It will be understood that the search manager can use avariety of techniques to map the bucket to a search node 506 accordingto a search node-data mapping policy. For example, the search manager514 can use previous assignments, network architecture, etc., to assignbuckets to search nodes 506 according to the search node-data mappingpolicy.

At block E1208, the search manager 514 instructs the search nodes 506 toexecute the query, as described in greater detail herein at least withreference to block 4906 of FIG. 49 and block B1208 of FIG. 12B.

Fewer, more, or different blocks can be used as part of the routineE1200. In some cases, one or more blocks can be omitted. In someembodiments, the blocks of routine E1200 can be combined with any one orany combination of blocks described herein with reference to at leastFIGS. 10A-10D, 12A-12D, 12F, 12G, 15A-15G, and 16A. In addition, it willbe understood that the various blocks described herein with reference toFIG. 12E can be implemented in a variety of orders, or implementedconcurrently.

4.3.6. Obtaining Data for Query Execution

FIG. 12F is a flow diagram illustrative of an embodiment of a routineF1200 implemented by a search node 506 to execute a search on a bucket.Although reference is made to downloading and searching a bucket, itwill be understood that this can refer to downloading and searching oneor more files associated within a bucket and does not necessarily referto downloading all files associated with the bucket.

Further, although described as being implemented by the search node 506,it will be understood that the elements outlined for routine F1200 canbe implemented by one or more computing devices/components that areassociated with the data intake and query system 108, such as, but notlimited to, the query system manager 502, the search head 504, thesearch master 512, search manager 514, cache manager 516, etc. Thus, thefollowing illustrative embodiment should not be construed as limiting.

At block F1202, the search node 506 receives instructions for a query orsub-query. As described herein, a search manager 514 can receive andparse a query to determine the tasks to be assigned to the search nodes506, such as, but not limited to, the searching of one or more bucketsin common storage 216, etc. The search node 506 can parse theinstructions and identify the buckets that are to be searched. In somecases, the search node 506 can determine that a bucket that is to besearched is not located in the search nodes local or shared data store.

At block F1204, the search node 506 obtains the bucket from commonstorage 216. As described herein, in some embodiments, the search node506 obtains the bucket from common storage 216 in conjunction with acache manager 516. For example, the search node 506 can request thecache manager 516 to identify the location of the bucket. The cachemanager 516 can review the data stored in the local or shared data storefor the bucket. If the cache manager 516 cannot locate the bucket in thelocal or shared data store, it can inform the search node 506 that thebucket is not stored locally and that it will be retrieved from commonstorage 216. As described herein, in some cases, the cache manager 516can download a portion of the bucket (e.g., one or more files) andprovide the portion of the bucket to the search node 506 as part ofinforming the search node 506 that the bucket is not found locally. Thesearch node 506 can use the downloaded portion of the bucket to identifyany other portions of the bucket that are to be retrieved from commonstorage 216.

Accordingly, as described herein, the search node 506 can retrieve allor portions of the bucket from common storage 216 and store theretrieved portions to a local or shared data store.

At block F1206, the search node 506 executes the search on the portionsof the bucket stored in the local data store. As described herein, thesearch node 506 can review one or more files of the bucket to identifydata that satisfies the query. In some cases, the search nodes 506searches an inverted index to identify the data. In certain embodiments,the search node 506 searches the raw machine data, uses one or moreconfiguration files, regex rules, and/or late binding schema to identifydata in the bucket that satisfies the query.

Fewer, more, or different blocks can be used as part of the routineF1200. For example, in certain embodiments, the routine F1200 includesblocks for requesting a cache manager 516 to search for the bucket inthe local or shared storage, and a block for informing the search node506 that the requested bucket is not available in the local or shareddata store. As another example, the routine F1200 can include performingone or more transformations on the data, and providing partial searchresults to a search manager 514, etc. In some embodiments, the blocks ofroutine F1200 can be combined with any one or any combination of blocksdescribed herein with reference to at least FIGS. 10A-10D, 12A-12E, 12G,15A-15G, and 16A. In addition, it will be understood that the variousblocks described herein with reference to FIG. 12F can be implemented ina variety of orders, or implemented concurrently.

4.3.7. Caching Search Results

FIG. 12G is a flow diagram illustrative of an embodiment of a routineG1200 implemented by the query system 214 to store search results.Although described as being implemented by the search manager 514, itwill be understood that the elements outlined for routine G1200 can beimplemented by one or more computing devices/components that areassociated with the data intake and query system 108, such as, but notlimited to, the query system manager 502, the search head 504, thesearch master 512, the search nodes 506, etc. Thus, the followingillustrative embodiment should not be construed as limiting.

At block G1202, the search manager 514 receives a query, as described ingreater detail herein at least with reference to block 4902 of FIG. 49,and at block G1204, the search manager 514 executes the query, asdescribed in greater detail herein at least with reference to blockB1208 of FIG. 12B. For example, as described herein, the search manager514 can identify buckets for searching assign the buckets to searchnodes 506, and instruct the search nodes 506 to search the buckets.Furthermore, the search manager can receive partial results from each ofthe buckets, and perform one or more transformations on the receiveddata.

At block G1206, the search manager 514 stores the results in theaccelerated data store 222. As described herein, the results can becombined with results previously stored in the accelerated data store222 and/or can be stored for combination with results to be obtainedlater in time. In some cases, the search manager 514 can receive queriesand determine that at least a portion of the results are stored in theaccelerated data store 222. Based on the identification, the searchmanager 514 can generate instructions for the search nodes 506 to obtainresults to the query that are not stored in the accelerated data store222, combine the results in the accelerated data store 222 with resultsobtained by the search nodes 506, and provide the aggregated searchresults to the client device 204, or store the aggregated search resultsin the accelerated data store 222 for further aggregation. By storingresults in the accelerated data store 222, the search manager 514 canreduce the search time and computing resources used for future searchesthat rely on the query results.

Fewer, more, or different blocks can be used as part of the routineG1200. In some cases, one or more blocks can be omitted. For example, incertain embodiments, the search manager 514 can consult a data storecatalog 220 to identify buckets, consult a resource catalog 510 toidentify available search nodes, map buckets to search nodes 506, etc.Further, in some cases, the search nodes 506 can retrieve buckets fromcommon storage 216. In some embodiments, the blocks of routine G1200 canbe combined with any one or any combination of blocks described hereinwith reference to at least FIGS. 10A-10D, 12A-12F, 15A-15G, and 16A. Inaddition, it will be understood that the various blocks described hereinwith reference to FIG. 12G can be implemented in a variety of orders, orimplemented concurrently.

4.3.8. Dynamic Assignment of Search Head and Search Nodes

FIG. 12H is a flow diagram illustrative of an embodiment of a routineH1200 implemented by the query system 214 to execute a query. Althoughdescribed as being implemented by the query system 214, it will beunderstood that the elements outlined for routine H1200 can beimplemented by one or more computing devices/components that areassociated with the data intake and query system 108, such as, but notlimited to, the query system manager 502, the search head 504, thesearch master 512, the search manager 514, the search nodes 506, etc.Thus, the following illustrative embodiment should not be construed aslimiting.

At block H1202, the query system 214 receives a query. In some cases, aquery system manager 502 of the query system 214 may perform thefunction of receiving the query. In some cases, the query system manager502 can receive the query from a client device 204. The query can be ina query language as described in greater detail above.

At block H1204, the query system 214 may dynamically assign acontainerized search head 504 to process the query. In some cases, thequery system manager 502 can dynamically assign a containerized searchhead 504 to process the query. In some embodiments, the query systemmanager 502 can query a resource catalog 510, which may track theavailability, responsiveness, and/or utilization rate of thecontainerized search heads that have been instantiated in the system toidentify and/or assign a search head 504 to process the query. Incertain embodiments, the query system 214 can use a search head mappingpolicy to dynamically assign a containerized search head 504 for thequery. In certain cases, the search head mapping policy can indicatethat a search head 504 is to be assigned based on its availability, asindicated by the resource catalog 510.

In certain embodiments, once assigned, the containerized search head 504can review the query. For example, the search head 504 can determinewhether the query was submitted by an authenticated user and/or reviewthe query to determine that it is in a proper format for the data intakeand query system 108, has correct semantics and syntax, etc. In someembodiments, the query system manager 502 or other component of thequery system can review the query as described prior to the assignmentof a search head 504. In some cases, the search head 504 can use asearch master 512 to receive search queries, and in some cases, spawnthe search manager 514 to process and execute the query.

As described herein, the query system 214 can include multiplecontainerized search heads 504 to process queries. One or more of thecontainerized search heads 504 can be instantiated on the same computingdevice, and share the resources of the computing device. In addition,based on resource availability and/or workload, the query system 214 caninstantiate additional containerized search heads 504 or terminatecontainerized search heads 504. As described herein, each search head504 can be implemented using containerization or operating-system-levelvirtualization, or other virtualization technique. For example, thecontainerized search head 504, or one or more components of the searchnode 506 can be implemented as separate containers or containerinstances. Each container instance can have certain resources (e.g.,memory, processor, etc.) of the underlying computing system assigned toit, but may share the same operating system and may use the operatingsystem's system call interface. Further, each container may run the sameor different computer applications concurrently or separately, and mayinteract with each other. It will be understood that othervirtualization techniques can be used. For example, the containerizedsearch heads 504 can be implemented using virtual machines using fullvirtualization or paravirtualization, etc.

At block H1206, the query system 214 can assign one or morecontainerized search nodes, e.g., search nodes 506, to execute thequery. In some cases, the search manager 514 of the assignedcontainerized search head 504 and/or the resource monitor 508 canidentify and assign one or more containerized search nodes 506 toexecute the query. In some cases, the search manager 514 can identifythe search nodes 506 using the resource catalog 510 and/or based on asearch node mapping policy. For example, as described herein, a resourcemonitor 508 can monitor the status of the search nodes 506 instantiatedin the query system 214 and store the status of the search nodes 506 inthe resource catalog 510. Based on the search node mapping policy, thequery system 214 can dynamically assign a group of containerized searchnodes 506 based on the availability of those containerized search nodes506, as indicated by the resource catalog 510.

As described herein, the query system 214 can include multiplecontainerized search nodes 506 to execute queries. One or more of thecontainerized search nodes 506 can be instantiated on the same computingdevice, and share the resources of the computing device. In addition,the containerized search nodes 506 can enable the query system 214 toprovide a highly extensible and dynamic searching service. For example,based on resource availability and/or workload, the query system 214 caninstantiate additional containerized search nodes 506 or terminatecontainerized search nodes 506.

As described herein, each search node 506 can be implemented usingcontainerization or operating-system-level virtualization, or othervirtualization technique. For example, the containerized search node506, or one or more components of the search node 506 can be implementedas separate containers or container instances. Each container instancecan have certain resources (e.g., memory, processor, etc.) of theunderlying computing system assigned to it, but may share the sameoperating system and may use the operating system's system callinterface. Further, each container may run the same or differentcomputer applications concurrently or separately, and may interact witheach other. It will be understood that other virtualization techniquescan be used. For example, the containerized search nodes 506 can beimplemented using virtual machines using full virtualization orparavirtualization, etc.

In some embodiments, the search node 506 can be implemented as a groupof related containers or a pod, and the various components of the searchnode 506 can be implemented as related containers of a pod. Further, thesearch node 506 can assign different containers to execute differenttasks. For example, one container of a containerized search node 506 canreceive and query instructions, a second container can obtain the dataor buckets to be searched, and a third container of the containerizedsearch node 506 can search the buckets and/or perform one or moretransformations on the data. However, it will be understood that thecontainerized search node 506 can be implemented in a variety ofconfigurations. For example, in some cases, the containerized searchnode 506 can be implemented as a single container and can includemultiple processes to implement the tasks described above by the threecontainers. Any combination of containerization and processed can beused to implement the containerized search node 506 as desired.

At H1208, the search manager 514 instructs the search nodes 506 toexecute the query. As described herein, the search manager 514 canprocess the query to determine portions of the query that it willexecute and portions of the query to be executed by the search nodes506. Furthermore, the search manager 514 can generate instructions orsub-queries for each search node 506 that is to execute a portion of thequery. In some cases, the search manager 514 generates a DAG forexecution by the search nodes 506. The instructions or sub-queries canidentify the data or buckets to be searched by the search nodes 506. Inaddition, the instructions or sub-queries may identify one or moretransformations that the search nodes 506 are to perform on the data.

Fewer, more, or different blocks can be used as part of the routineH1200. In some cases, one or more blocks can be omitted. For example, incertain embodiments, the search manager 514 can receive partial resultsfrom the search nodes 506, process the partial results, perform one ormore transformation on the partial results or aggregated results, etc.Further, in some embodiments, the search manager 514 provide the resultsto a client device 204. In some embodiments, the search manager 514 cancombine the results with results stored in the accelerated data store222 or store the results in the accelerated data store 222 forcombination with additional search results.

In some cases, the search manager 514 can identify the data or bucketsto be searched by, for example, using the data store catalog 220, andmap the buckets to the search nodes 506 according to a search node-datamapping policy. As described herein, the data store catalog 220 canreceive updates from the indexing system 212 about the data that isstored in common storage 216. The information in the data store catalog220 can include, but is not limited to, information about the locationof the buckets in common storage 216, and other information that can beused by the search manager 514 to identify buckets that include datathat satisfies at least a portion of the query.

In certain cases, as part of executing the query, the search nodes 506can obtain the data to be searched from common storage 216 using thecache manager 516. The obtained data can be stored on a local or shareddata store and searched as part of the query. In addition, the data canbe retained on the local or shared data store based on a bucket cachingpolicy as described herein.

Furthermore, it will be understood that the various blocks describedherein with reference to FIG. 12H can be implemented in a variety oforders. In some cases, the search manager 514 can implement some blocksconcurrently or change the order as desired. For example, the searchmanager 514 can concurrently dynamically assign search nodes 506 toexecute the query and instruct the search nodes 506 to execute thequery. As described herein, in some embodiments, the search manager 514can instruct the search nodes 506 to execute the query at once.

4.3.9. Identifying Available Search Head Using Resource Catalog

FIG. 12I is a flow diagram illustrative of an embodiment of a routineI1200 implemented by the query system 214 to identify search heads forquery processing. Although described as being implemented by the querysystem 214, it will be understood that the elements outlined for routineI1200 can be implemented by one or more computing devices/componentsthat are associated with the data intake and query system 108, such as,but not limited to, the query system manager 502, the search head 504,the search master 512, the search manager 514, the search nodes 506,etc. Thus, the following illustrative embodiment should not be construedas limiting.

At block I1202, the query system 214 maintains a catalog of instantiatedsearch heads 504. As described herein, the catalog can also be referredto as the resource catalog 510, and can include information about thesearch heads 504, such as, but not limited to, availability,utilization, responsiveness, network architecture, etc. Further, theresource catalog 510 can be kept up-to-date based on informationreceived by the resource monitor 508 from the search heads 504.

At block I1204, the query system 214 receives a query. In some cases,the search manager 514 performs the function of receiving a query, asdescribed in greater detail herein at least with reference to block 1502of FIG. 15. At block I1206, the query system 214 identifies availablesearch heads 504 using the resource catalog 510 and/or based on a searchhead mapping policy. For instance, the query system 214 may query theresource catalog 510, which tracks the availability, responsiveness,and/or utilization rate of the various search heads 504. The querysystem 214 may identify a search head 504 to process the query based onthe availability of that search head 504, as indicated by the resourcecatalog 510 and/or based on the search head mapping policy.

At block I1208, the query system 214 assigns the identified search head504 to process the query. As described herein, based on a search headmapping policy, the query system 214 can assign a search head to processthe query.

Fewer, more, or different blocks can be used as part of the routineI1200. For example, as described herein, the search head 504 can processthe query, identify one or more search nodes 506 (non-limiting examples;based on a search node mapping policy) to execute the query, generatequery execution instructions for the identified search nodes 506,initiate execution of the query, receive partial results from the searchnodes 506, finalize the results of the query, and provide the results toa user, etc.

In some cases, one or more blocks can be omitted. In addition, it willbe understood that the various blocks described herein with reference toFIG. 12I can be implemented in a variety of orders, or implementedconcurrently. For example, the query system can concurrently receivemultiple queries (associated with the same or different dataidentifiers) and assign the queries to the same or different searchheads 504.

4.3.10. Mapping Search Nodes to a Search Head

FIG. 12J is a flow diagram illustrative of an embodiment of a routineJ1200 implemented by the query system 214 to map search nodes to asearch head. Although described as being implemented by the search head504, it will be understood that the elements outlined for routine J1200can be implemented by one or more computing devices/components that areassociated with the data intake and query system 108, such as, but notlimited to, the query system manager 502, the search head 504, thesearch master 512, the search manager 514, the search nodes 506, etc.Thus, the following illustrative embodiment should not be construed aslimiting.

At block J1202, the query system 214 receives a query. In some cases, aquery system manager 502 can receive the query. In some cases, the querysystem manager 502 can receive the query from a client device 204. Thequery can be in a query language as described in greater detail above.The query may be associated with a tenant (e.g., received from a userassociated with the tenant) and also be associated with a tenantidentifier.

At block J1204, the query system 214 can identify a search head 504 toprocess the query. In some cases, the query system manager 502 and/orresource monitor 508 of the query system 214 can identify the searchhead 504 to process the query. For example, the query system 214 canquery a resource catalog 510, which can be used to track availability,responsiveness, and/or utilization rate of the search heads 504 in thequery system 214. The query system 214 may identify a search head 504based on a search head mapping policy, as described herein.

At block J1206, the query system 214 can map search nodes 506 to thesearch head 504. In certain embodiments, the query system 214 can mapthe search nodes to the search head based on a search node mappingpolicy. In some cases, the search node mapping policy can indicate thatthe search nodes 506 are mapped to the search head 504, search manager514, or query based on a tenant identifier associated with the query. Incertain embodiments, the query system 214 can identify search nodes 506to map to the search head 504 using a search node-data mapping policy,previous mappings, previous searches, or the contents of a data storeassociated with the search nodes 506. For example, based on the previousassignment of a search node 506 to search data as part of a query, thequery system 214 can assign the search node 506 to search the same datafor a different query. As another example, as search nodes 506 searchdata, it can cache the data in a local or shared data store. Based onthe data in the cache, the query system 214 can assign the search node506 to search the data again as part of a different query.

In certain embodiments, the query system 214 can identify search nodes506 based on shared resources. For example, if the query system 214determines that a search node 506 shares a data store with a search node506 that previously performed a search on data and cached the data inthe shared data store, the query system 214 can assign the search node506 that share the data store to search the data stored therein as partof a different query.

In some embodiments, the query system 214 can identify search nodes 506using a hashing algorithm. For example, as described herein, the querysystem 214 based can perform a hash on the tenant identifier associatedwith the query to identify a group of search nodes. In someimplementations, that hash may be a consistent hash, to increase thechance that the same search nodes will be selected for the tenantidentifier as was previously used. In some such embodiments, the querysystem 214 can perform a hash on the data identifier and search nodeidentifiers of one or more search nodes 506, and map the search nodes506 to the query based on the hashes.

It will be understood that the query system 214 can identify and mapsearch nodes 506 based on any one or any combination of theaforementioned methods. Furthermore, it will be understood that thequery system 214 can identify search nodes 506 in a variety of ways. Thequery system 214 can use a variety of techniques to map a group ofsearch nodes 506 to a search head according to a search node mappingpolicy, or another policy. For example, the search manager 514 can useprevious assignments, network architecture, etc., to assign search nodes506 to the search head 504, to the query, or to the data identifierassociated with the query.

At block J1208, the query system 214 can process the query using theidentified search head 504. In some embodiments, the search head 504 canreview the query. For example, the search head 504 can determine whetherthe query was submitted by an authenticated user and/or review the queryto determine that it is in a proper format for the data intake and querysystem 108, has correct semantics and syntax, etc. In some cases, thesearch head 504 can use a search master 512 to receive search queries,and in some cases, spawn the search manager 514 to process and executethe query. In certain embodiments, as part of processing the query, thesearch head 504 can identify tasks for it to complete and tasks for thesearch nodes 506 to complete, generate instructions or sub-queries forthe search nodes 506, etc.

At J1210, the query system 214 executes the query. As described herein,at least with reference to 1506 of FIG. 15, in some embodiments, as partof executing the query, the search head 504 can communicate the query orsubquery instructions to the search nodes 506 for execution. Further,the search head 504 can aggregate the results from the search nodes 506and perform one or more transformations on the data.

Fewer, more, or different blocks can be used as part of the routineJ1200. In some cases, one or more blocks can be omitted. For example, asdescribed herein, the query system 214 can map the search nodes 506 tocertain data or buckets for the search according to a search node-datamapping policy.

In addition, it will be understood that the various blocks describedherein with reference to FIG. 12J can be implemented in a variety oforders, or implemented concurrently. For example, the search manager 514can identify search nodes to execute the query and identify bucket forthe query concurrently or in any order.

4.4. Querying Using Metadata Catalog

As described herein, the metadata catalog 221 can be used to storeinformation related to various datasets 608 and/or rules 610 used by thedata intake and query system to process data. In some embodiments, themetadata catalog 221 can be used to process and/or execute queriesreceived by the data intake and query system 108.

4.4.1 Metadata Catalog Data Flow

FIG. 13 is a data flow diagram illustrating an embodiment of the dataflow and communications between a variety of the components of the dataintake and query system 108 during execution of a query. Specifically,FIG. 13 is a data flow diagram illustrating an embodiment of the dataflow and communications between the metadata catalog 221, the querysystem manager 502, and the search head 504. However, it will beunderstood, that in some of embodiments, one or more of the functionsdescribed herein with respect to FIG. 13 can be omitted, performed in adifferent order and/or performed by the same or a different component ofthe data intake and query system 108. For example, in some embodiments,the steps identified as being performed by the query system manager 502and search head 504 can be performed by the same component (e.g., thequery system manager 502, the search head 504, or another component ofthe data intake and query system 108). In some such embodiments, (4′)can be omitted.

Furthermore, in some embodiments, the data flow diagram illustrated atFIG. 13 can be performed prior to (5) of the data flow diagramillustrated in FIG. 11. For example, (5) of FIG. 11 references receivinga query at the search head 504. In some embodiments, the query receivedat the search head 504 can correspond to the system query communicatedto the search head 504 by the query system manager 502 at (4′) of FIG.13.

At (1′), a query system manager 502 receives and processes a user query.The user query can correspond to a query received from a client device204 and can include one or more query parameters. In some cases, theuser query can be received via the gateway 215 and/or via the network208. The query can identify (and the query parameters can include) a setof data and manner processing the set of data. In certain embodimentsthe set of data of a query can include multiple datasets. For example,the set of data of the query can include one or more source datasets,source reference datasets and/or query datasets. In turn a dataset caninclude one or more queries (or subqueries). For example, a querydataset can be identified as at least a portion of the set of data of areceived query, and can include a query (or subquery) that identifies aset of data and a manner of processing the set of data. As anotherexample, the query dataset could reference one or more additional querydatasets that in turn include one or more subqueries.

Furthermore, the query can include at least one dataset identifierand/or dataset association record identifier. In some embodiments, thedataset identifier can be a logical identifier of a dataset. In certainembodiments, the dataset identifier and/or dataset association recordidentifier can follow a particular query parameter, such as “from”“datasetID,” “moduleID,” etc. In some embodiments, the datasetidentifier and/or dataset association record identifier can be includedas a parameter of a command received by the query system manager 502.For example, in some embodiments, the data intake and query system 108can receive the query as one parameter and the dataset identifier and/orthe dataset association record as another parameter.

As part of processing the user query, the query system manager 502 canidentify the dataset identifier(s) and/or the dataset association recordidentifier. In some embodiments, the query system manager 502 can parsethe query to identify the dataset identifier and/or dataset associationrecord identifier. For example, the query system manager 502 canidentify “from” (or some other query parameter) in the query anddetermine that the subsequent string is the dataset identifier.Furthermore, it will be understood that the query system manager 502 canidentify multiple dataset identifier(s) and/or dataset associationrecord identifier(s) as part of processing the user query.

At (2′), the query system manager 502 communicates with the metadatacatalog 221 to authenticate the datasets identified in the query (andother datasets parsed during the query processing), identify primarydatasets (e.g. datasets with configurations used to execute the query),secondary datasets (datasets referenced directly or indirectly by thequery but that do not include configurations used to execute the query)and/or identify query configuration parameters.

In some embodiments, upon identifying a dataset association record 602associated with the query, the query system manager 502 uses the datasetassociation record 602 to identify additional information associatedwith the user query, such as one or more datasets and/or rules. In someembodiments, using the dataset association record, the query systemmanager 502 can determine whether a user associated with the query hasthe authorizations and/or permissions to access the datasets identifiedin the query.

Once the query system manager 502 identifies the dataset of the datasetassociation record 602 referenced in the query, the query system manager502 can determine whether the identified dataset identifies one or moreadditional datasets (e.g., is a single or multi-reference dataset),includes additional query parameters, is a source dataset, a secondarydataset, and/or a primary dataset that will be used by the data intakeand query system to execute the query.

In the event, the dataset is a single or multi-reference dataset, witheach additional dataset identified, the query system manager 502 canrecursively review information about the dataset to determine whether itis a non-referential, single, or multi-reference dataset, a secondarydataset, and/or a primary dataset until it has identified any datasetreferenced directly or indirectly by the query (e.g., all primary andsecondary datasets). For example, as described in herein, the datasetidentifier used in the user query may refer to a dataset that is fromanother dataset association record. Based on the determination that thedataset is imported, the query system manager 502 can review the otherdataset association record to identify any additional datasets, identifyconfiguration parameter (e.g., access information, dataset type, etc.)of the imported dataset, and/or determine whether the referenced datasetwas imported from a third dataset. The query system manager 502 cancontinue to review the dataset association records 602 until it hasidentified the dataset association record where the dataset is native.

As another example, the dataset identifier in the user query may referto a multi-reference dataset, such as a query dataset that refers to oneor more source datasets, source reference datasets, and/or other querydatasets. Accordingly, the query system manager 502 can recursivelyreview the datasets referred to in the multi-reference dataset until itidentifies datasets that do not rely on any other datasets (e.g.,non-referential datasets) and/or identifies the source datasets thatinclude the data that forms at least a portion of the set of data orother primary datasets.

With each new dataset identified from the dataset association records,the query system manager 502 can authenticate the dataset. As part ofauthenticating the datasets, the query system manager 502 can determinewhether the dataset referred to is imported by the dataset associationrecord and/or whether the user has the proper credentials,authorizations, and/or permissions to access the dataset.

In addition to identifying additional datasets, the query system manager502 can identify additional query parameters. For example, one or moredatasets, such as a query dataset, may include additional queryparameters. Accordingly, as the query system manager 502 parses thevarious datasets, it can identify additional query parameters that areto be processed and/or executed.

Furthermore, as the query system manager 502 parses the datasetassociation records 602, it can identify one or more rules that are tobe used to process data from one or more datasets. As described herein,the rules can be imported by different dataset association records 602.Accordingly, the query system manager 502 can recursively parse therules to identify the dataset association record 602 from which the ruleoriginated. Furthermore, as the query system manager 502 parses thedataset association records 602 and identifies additional rules, it candetermine whether the user has the proper credentials permissions etc.to access the identified rules. In addition, the query system manager502 can identify one or more datasets associated with the rules (e.g.,that reference, use, are referenced by, or used by, the additionalrules). As described herein, in some embodiments these datasets may notbe explicitly imported in a dataset association record, but may beautomatically included as part of the query processing process.

In addition to identifying the various datasets and/or rules associatedwith the query, the query system manager 502 can identify theconfigurations associated with the datasets and rules associated withthe query. In some embodiments, the query system manager 502 can use thedataset configuration records 604 and/or rule configuration records 606to identify the relevant configurations for the datasets and/or rulesassociated with the query. For example, the query system manager 502 canrefer to the dataset configuration records 604 to identify the datasettypes of the various datasets associated with the query. In someembodiments, based on the dataset type, the query system manager 502 candetermine how to interact with or generate commands for the dataset. Forexample, for a lookup dataset, the query system manager may generate a“lookup” command, for an “index” dataset, the query system manager maygenerate a “search” command, and for a metrics interaction dataset, thequery system manager may generate an “mstats” command.

As described herein, in some embodiments, the dataset configurationrecords 604 and rule configuration records 606 can include a physicalidentifier for the datasets and/or rules. Accordingly, in someembodiments, the query system manager 502 can obtain the physicalidentifiers for each of the datasets and/or rules associated with thequery. In certain embodiments, the query system manager 502 candetermine the physical identifiers for each of the datasets and/or rulesassociated with the query based on the logical name and datasetassociation record 602 associated with the dataset or rule. For example,in certain embodiments, the physical identifier can correspond to acombination of the logical identifier of the dataset and the logicalidentifier of the associated dataset association record.

In some embodiments, when identifying the rule configuration records 606and/or dataset configuration records 604, the query system manager 502can obtain a subset of the dataset configuration records 604 and/or ruleconfiguration records 606 in the metadata catalog 221 and/or a subset ofthe dataset configuration records 604 and/or rule configuration records606 associated with the dataset association records 602 identified bythe query or referenced while processing the query. In certainembodiments, the query system manager 502 obtains only the datasetconfiguration records 604 and/or rule configuration records 606 that areneeded to process the query or only the primary dataset configurationrecords 604 and primary rule configuration records 606. For example, ifthe dataset association record 602 reference three datasets and tworules, but the query only uses one of the datasets and one of the rules,the query system manager 502 can obtain the dataset configuration record604 of the dataset referenced and the rule configuration record 606 inthe query but not the dataset configuration records 604 and ruleconfiguration records 606 of the datasets and rule not referenced in orused by the query.

At (3′), the query system manager 502 generates a system query and/orgroups query configuration parameters. The query configurationparameters can include the dataset configuration records 604corresponding to the primary datasets and/or the rule configurationrecords 606 corresponding to the rules associated with the query orprimary rules.

In some embodiments, the system query can be based on the user query,one or more primary or secondary datasets, the physical name of aprimary dataset(s), the dataset type of the primary dataset(s),additional query parameters identified from the datasets, and/or basedon information about the search head 504, etc. In certain embodiments,the system query corresponds to the user query modified to be compatiblewith the search head 504. For example, in some embodiments, the searchhead 504 may not be able to process one or more commands in the systemquery. Accordingly, the query system manager 502 can replace thecommands unsupported by the search head 504 with commands that aresupported by the search head 504.

In some embodiments, as the system query parses the dataset associationrecords 602 and/or dataset configuration records 604, it identifies thedatasets to be included in the query. In certain embodiments, the querysystem manager 502 identifies the datasets to be included based on thedataset identifier(s) included in the query. For example, if the queryidentifies a source dataset or source reference dataset, the querysystem manager 502 can include an identifier for the source dataset orsource reference dataset in the system query. Similarly, if the queryidentifies a single or multi-reference dataset, the query system manager502 can include an identifier for the single or multi-reference datasetin the system query and/or may include an identifier for one or more(primary) datasets referenced by the single or multi-reference datasetin the system query

In some embodiments, the query system manager 502 identifies thedatasets to be included based on the dataset identifier(s) included inthe query and/or one or more query parameters of a dataset referenced bythe query. For example, if the query identifies (or references) a querydataset, the query system manager 502 can include the query parameters(including any referenced primary datasets) of the query dataset in thequery. As another example, the query system manager 502 can recursivelyparse the query parameters (including any referenced datasets) of thequery dataset to identify primary datasets and instructions forprocessing data from (or referenced by) the primary datasets, andinclude the identified primary datasets and instructions for processingthe data in the query. Similarly, if a query dataset references one ormore single reference or multi-reference datasets, the query systemmanager 502 can recursively process the single reference ormulti-reference datasets referenced by the query dataset until itidentifies the query parameters referenced by any dataset referenced bythe query dataset and the primary datasets that include (or reference)the data to be processed according to the identified query parameters.

In certain embodiments, the system query replaces any logical datasetidentifier of the user query (such as a query dataset) with the physicaldataset identifier of a primary dataset or source dataset identifiedfrom the metadata catalog 221. For example, if the logical name of adataset is “main” and the dataset association record 602 is “test,” thequery system manager 502 can replace “main” with “test.main” or“test_main,” as the case may be. Accordingly, the query system manager502 can generate the system query based on the physical identifier ofthe primary datasets or source datasets.

In some embodiments, the query system manager 502 generates the systemquery based on the dataset type of one or more primary datasets, sourcedatasets, or other datasets to be referenced in the system query. Forexample, datasets of different types may be interacted with usingdifferent commands and/or procedures. Accordingly, the query systemmanager 502 can include the command associated with the dataset type ofthe dataset in the query. For example, if the dataset type is an indextype, the query system manager 502 can replace a “from” command with a“search” command. Similarly, if the dataset type is a lookup type, thequery system manager 502 can replace the “from” command with a “lookup”command. As yet another example, if the dataset type is a metricsinteractions type, the query system manager 502 can replace the “from”command with an “mstats” command. As yet another example, if the datasettype is a view dataset, the query system manager 502 can replace the“from” and dataset identifier with a query identified by the viewdataset. Accordingly, in certain embodiments, the query system manager502 can generate the system query based on the dataset type of one ormore primary datasets.

In certain embodiments, the query system manager 502 does not includeidentifiers for any secondary datasets used to parse the user query. Insome cases, as the query system manager 502 parses the datasetreferenced by a query, it can determine whether a dataset associatedwith the query will be used to execute the query. If not, the datasetcan be omitted from the system query. For example, if a query datasetincludes query parameters, which reference two source datasets, thequery system manager 502 can include the query parameters andidentifiers for the two source dataset in the system query. Havingincluded the content of the query dataset in the query, the query systemmanager 502 can determine that no additional information orconfigurations from the query dataset will be used by the query or toexecute the query. Accordingly, the query system manager 502 candetermine that the query dataset is a secondary dataset and omit it fromthe query.

In some embodiments, the query system manager 502 includes only datasets(or source datasets or source reference datasets) explicitly referencedin the user query or in a query parameter of another dataset in thesystem query. For example, if the user query references a “main” sourcedataset, the “main” source dataset will only be included in the query.As another example, if the user query (or a query parameter of anotherdataset, such as a query dataset) includes a “main” source dataset and a“test” source reference dataset, only the “main” source dataset and“test” source reference dataset, will be included in the system query.However, it will be understood that the query system manager 502 can usea variety of techniques to determine whether to include a dataset in thesystem query.

In certain embodiments, the query system manager 502 can identify queryconfiguration parameters (configuration parameters associated with thequery) based on the primary datasets and/or rules associated with thequery. For example, as the query system manager 502 parses the datasetconfiguration records 604 of the datasets referenced (directly orindirectly) by the user query it can determine whether the datasetconfiguration records 604 are to be used to execute the system query.

In some cases, to determine whether the dataset configuration record 604is to be used to execute the query, the query system manager 502 canparse a generated system query. In parsing the system query, the querysystem manager 502 can determine that the datasets referenced in thesystem query will be used to execute the system query. Accordingly, thequery system manager 502 can obtain the dataset configuration records604 corresponding to the datasets referenced in the system query. Forexample, if a system query references the “test.main” dataset, the querysystem manager 502 can obtain the dataset configuration record 604 ofthe “test.main” dataset.

In addition, in some cases, the query system manager can identify anydatasets referenced by the datasets in the system query and obtain thedataset configuration records 604 of the datasets referenced by thedatasets in the system query. For example, if the system queryreferences a “users” source reference dataset, the query system manager502 can identify the source dataset referenced by the “users” sourcereference dataset and obtain the corresponding dataset configurationrecords 604, as well as the dataset configuration record 604 for the“users” source reference dataset.

In certain embodiments, the query system manager 502 can identify andobtain dataset configuration records 604 for any source dataset(s) andsource reference dataset(s) referenced (directly or indirectly) by thequery.

In some embodiments, the query system manager 502 can identify andobtain rules configurations 606 for any rules referenced by: the (systemor otherwise) query, a dataset included in the system (or othergenerated) query, a dataset for which a dataset configuration record 604is obtained as part of the query configuration parameters, and/or adataset association record referenced (directly or indirectly) by theuser query. In some cases, the query system manager 502 includes allrules associated with the dataset association record(s) associated withthe query in the query configuration parameters. In certain cases, thequery system manager 502 includes a subset of the rules associated withthe dataset a dataset association record(s) associated with the query.For example, the query system manager 502 can include rule configurationrecords 606 for only the rules referenced by or associated with adataset that is also being included in the query configurationparameters.

As described herein, the query system manager 502 can obtain the datasetconfiguration records 604 and/or rule configuration records 606 from themetadata catalog 221 based on a dynamic parsing of the user query.Accordingly, in some embodiments, the query system manager 502 candynamically identify the query configuration parameters to be used toprocess and execute the query.

At (4′), the query system manager 502 communicates the system queryand/or query configuration parameters to the search head 504. Asdescribed herein, in some embodiments, the query system manager cancommunicate the system query to the search head 504. In certainembodiments, the query system manager 502 can communicate the queryconfiguration parameters to the search head 504. Accordingly, the querysystem manager 502 can communicate either the system query, the queryconfiguration parameters, or both.

In certain embodiments, by dynamically determining and communicating thequery configuration parameters to the search head 504, the query systemmanager 502 can provide a stateless search experience. For example, ifthe search head 504 becomes unavailable, the query system manager 502can communicate the dynamically determined query configurationparameters (and/or query to be executed) to another search head 504without data loss and/or with minimal or reduced time loss.

4.4.2 Example Metadata Catalog Processing

FIG. 14 is a data flow diagram illustrating an embodiment of the dataflow for identifying primary datasets, secondary datasets, and queryconfiguration parameters for a particular query 1402. In the illustratedembodiment, the query system manager 502 receives the query 1402, whichincludes the following query parameters “|fromthreats-encountered|sort-count|head 10.” In addition, “trafficTeam” isidentified as the identifier of a dataset association record 602Nassociated with the query 1402.

Based on the identification of “trafficTeam” as the dataset associationrecord identifier, the query system manager 502 (1) determines that the“trafficTeam” dataset association record 602N is associated with thequery, is to be searched, and/or determines a portion of the physicalname for datasets (or dataset configuration records 604) to be searched.

In addition, based on the query 1402, the query system manager 502identifies “threats-encountered” as a logical dataset identifier. Forexample, the query system manager 502 can determine that a datasetidentifier follows the “from” command. Accordingly, at (2), the querysystem manager 502 parses the “threats-encountered” dataset 608I (orassociated dataset configuration record 604). As part of parsing the“threats-encountered” dataset 608I, the query system manager 502determines that the “threats-encountered” dataset 608I is amulti-reference query dataset that references two additional datasets608J and 608H (“traffic” and “threats”). In some embodiments, the querysystem manager 502 can identify the related datasets 608J and 608H basedon a system annotation in the dataset configuration record 604N and/orbased on parsing the query of the dataset configuration record 604N.Based on the identification of the additional datasets, the query systemmanager 502 parses the “traffic” dataset 608J and the “threats” dataset608H (or associated dataset configuration record 604) at (3A) and (3B),respectively. Based on parsing the “threats” dataset 608H (orassociation dataset configuration record 604), the query system manager502 determines that the “threats” dataset 608H is a single sourcereference dataset that references or relies on the “threats-col” dataset608G. In certain cases, the query system manager 502 can identify the“threats-col” dataset 608G based on an annotation in the datasetconfiguration record 604 associated with the “threats” dataset 608H.Accordingly, at (4A) query system manager 502 parses the “threats-col”dataset 608G (or associated dataset configuration record 604). Based onparsing the “threats-col” dataset 608G, the query system manager 502determines that the “threats-col” dataset 608G is a non-referentialsource dataset.

Based on parsing the “traffic” dataset 608J, the query system manager502 determines that the “traffic” dataset 608J is an imported datasetthat corresponds to the “main” dataset 608A of the “shared” datasetassociation record 602A, which may also be referred to as the“shared.main” dataset 608A. In some cases, the query system manager 502can identify the “shared.main” dataset 608A based on the definition ofthe “traffic” dataset 608J in the dataset association record 602N orbased on an annotation in a dataset configuration record 604 associatedwith the dataset “traffic” 608H. Accordingly, at (4B), the query systemmanager 502 parses the “shared.main” dataset 608A (or associated datasetconfiguration record 604). Based on parsing the “shared.main” dataset608A, the query system manager 502 determines that the “shared.main”dataset 608A is a non-referential source dataset. In some embodiments,based on parsing the “shared.main” dataset 608A, the query systemmanager 502 can determine that the rule “shared.X” 610A is related tothe “shared.main” dataset 608A and begin parsing the rule “shared.X”610A based on the identification. This may be done in place of orconcurrently with step (4C) and (5) described below.

As part of parsing the “traffic” dataset 608J, the query system manager502 also determines that the “shared.X” rule 610B is associated with the“traffic” dataset 608J (e.g., based on its presence in the datasetassociation record 602N and/or based on another indication of arelationship, such as an annotation in a rule configuration record 606for the “shared.X” rule 610B or an annotation in a dataset configurationrecord 604 for the “shared.main” dataset 608A), and at (4C), parses the“shared.X” rule 610B (which may include parsing the rule configurationrecord 606 of the “shared.X” rule 610B). Based on parsing the “shared.X”rule 610B, the query system manager 502 determines that the “shared.X”rule 610B is imported from the “shared” dataset association record 602Aand at (5) parses the “X” rule 610A of the dataset association record602A. Based on parsing the “X” rule 610A (or associated ruleconfiguration record 606), the query system manager 502 determines thatthe “X” rule 610A references the “users” dataset 608C, and at (6) parsesthe “users” dataset 608C (or associated dataset configuration record604). Based on parsing the “users” dataset 608C, the query systemmanager 502 determines that the “users” dataset 608C references the“users-col” dataset 608D and at (7) parses the “users-col” dataset 608D.Based on parsing the “users-col” dataset 608D, the query system manager502 determines that the “users-col” dataset 608D is a non-referentialsource dataset.

In some embodiments, each time the query system manager 502 identifies anew dataset, it can identify the dataset as a dataset associated withthe query. As the query system manager 502 processes the dataset, it candetermine whether the dataset is a primary dataset or a secondarydataset. For example, if a view dataset merely references other datasetsor includes additional query parameters and the configurations of theview dataset will not be used (or needed) to execute the queryparameters or access the referenced datasets, it can be identified as asecondary dataset and omitted as a primary dataset. With reference tothe illustrated embodiment, the query system manager 502 may identify“threats-encountered” dataset 608I as being associated with the querybased on its presence in the user query 1402. However, once the querysystem manager 502 determines that the “threats-encountered” dataset608I adds additional query parameters to the query 1402, but does notinclude data and/or will not be used to execute the query, it canidentify the “threats-encountered” dataset 608I as secondary dataset butnot a primary dataset (and may or may not keep the query parameters).

As described herein, in some cases, the query system manager 502determines the physical names of the primary datasets based on datasetassociation records 602A, 602N. For example, the query system manager502 can use the names or identifiers of the dataset association records602A, 602N to determine the physical names of the primary datasetsand/or rules associated with the query. Using the physical names of theprimary datasets and/or rules associated with the query, the querysystem manager 502 (8) identifies the dataset configuration records 604from various dataset configuration records 604 and rule configurationrecords 606 from various rule configuration records 606 for inclusion asquery configuration parameters 1406. In some embodiments, the querysystem manager 502 can determine the dataset types of the primarydatasets and other query configuration parameters associated with theprimary datasets and rules associated with the query using the datasetconfiguration records 604 and rule configuration records 606.

In the illustrated embodiment, the query system manager 502 candetermine that the datasets 608B, 608E, and 608F are not datasetsassociated with the query as they were not referenced (directly orindirectly) by the query 1402. Conversely, in the illustratedembodiment, the query system manager 502 determines that datasets 608A,608C, 608D, 608G, 608H, 608I, and 608J are datasets associated with thequery as they were referenced (directly or indirectly) by the query1402.

In addition, in the illustrated embodiment, the query system manager 502determines that the “shared.main,” “shared.users,” “shared.users-col,”“trafficTeam.threats,” and “trafficTeam.threat-col” datasets 608A, 608C,608D, 608H, 608G, respectively, are primary datasets as they will beused to execute or process the system query 1404 and that the“trafficTeam.threats-encountered” dataset 608I and “trafficTeam.traffic”dataset 608J are secondary datasets as they will not be used toprocess/execute the query. Moreover, the query system manager 502determines that the rule “shared.X” is associated with the query and/orwill be used to process/execute the system query.

As mentioned, although, the “threats-encountered” and “traffic” datasets608I, 608J, respectively, were identified as part of the processing, thequery system manager 502 determines not to include them as primarydatasets as they are not source datasets or will not be used to executethe system query. Rather, the “threats-encountered” and “traffic”datasets 608I, 608J were used to identify other datasets and queryparameters. For example, the “threats-encountered” dataset 608I is aview dataset that includes additional query parameters that referencetwo other datasets, and the “traffic” dataset 608J is merely the name ofthe “shared.main” dataset 608A imported into the “trafficTeam” datasetassociation record 602N.

Based on the acquired information, the query system manager 502 (9)generates the system query 1404 and/or the query configurationparameters 1406 for the query. With reference to the system query 1404,the query system manager 502 has included query parameters identifiedfrom the “threats-encountered dataset” in the system query 1404 andreplaced the logical identifiers of datasets in the query with physicalidentifiers of the datasets (e.g., replaced “threats-encountered” with“shared.main” and “trafficTeam.threats”). In addition, the query systemmanager 502 includes commands specific to the dataset type of thedatasets in the query (e.g., “from” replaced with “search” for the“shared.main” dataset 608A and “lookup” included for the lookup“trafficTeam.threats” dataset 608H). Accordingly, the system query 1404is configured to be communicated to the search head 504 for processingand execution.

Moreover, based on the information from the metadata catalog 221, thequery system manager 502 is able to generate the query configurationparameters 1406 for the query to be executed by the data intake andquery system 108. In some embodiments, the query configurationparameters 1406 include dataset configuration records 604 (or portionsthereof) associated with: datasets identified in the query 1404,datasets referenced by the datasets identified in the query 1404, and/ordatasets referenced by a rule or rule configuration record 606 included(or identified for inclusion) in the query configuration parameters1406. In certain embodiments, the query configuration parameters 1406include dataset configuration records 604 (or portions thereof)associated with the primary datasets. In some cases, when includingdataset configuration records 604, the query system manager 502 may omitcertain portions of the dataset configuration records 604. For example,the query system manager 502 may omit one or more annotations, such asthe annotations identifying relationships between datasets or fields,etc. In certain embodiments, the query system manager 502 includes areference to the various dataset configuration records 604 rather than acopy of the dataset configuration records 604.

In some embodiments, the query configuration parameters 1406 includesrule configuration records 606 of rules associated with: the query(referenced directly or indirectly), datasets identified in the query1404, and/or datasets (or dataset configuration records 604) identifiedin the query configuration parameters 1406.

In some cases, the query system manager 502 can iteratively identifydataset configuration records 604 and/or rules configurations 606 forinclusion in the query configuration parameters 1406. As a non-limitingexample, the query system manager 502 can include a first datasetconfiguration record 604 in the query configuration parameters 1406(e.g., of a dataset referenced in the query to be executed). The querysystem manager 502 can then include dataset configuration records 604 orrule configuration records 606 of any datasets referenced by the firstdataset (or corresponding configuration 604). The query system manager502 can iteratively include dataset and rule configuration records 604,606 corresponding to datasets or rules referenced by an already includedrule or dataset (or corresponding configurations 604, 606) until therelevant dataset and rule configuration records 606 are included in thequery configuration parameters 1406. In certain embodiments, onlyconfigurations corresponding to primary datasets and primary rules areincluded in the query configuration parameters 1406. Less or additionalinformation or configurations can be included in the query configurationparameters 1406.

As another non-limiting example and with reference to the illustratedembodiment, the query system manager 502 can include the “shared.main”dataset configuration record 604 and “trafficTeam.threats” datasetconfiguration record 604 in the query configuration parameters 1406based on their presence in the query 1404. Based on a determination thatthe “trafficTeam.threats-col” dataset configuration record 604 isreferenced by the “trafficTeam.threats” dataset (or correspondingconfiguration 604), the query system manager 502 can include the“trafficTeam.threats-col” dataset configuration record 604 in the queryconfiguration parameters 1406.

Based on a determination that the “shared.X” rule is referenced by the“shared.main” dataset 608A or a determination that the “shared.X” ruleis included in the dataset association record 602N, the query systemmanager 502 can include the “shared.X” rule configuration record 606 inthe query configuration parameters 1406. Furthermore, based on adetermination that the “shared.users” dataset 608C is referenced by the“shared.X” rule (inclusive of any action of the “shared.X” rule orcorresponding configuration 606), the query system manager 502 caninclude the “shared.users” dataset 608C in the query configurationparameters 1406. Similarly, the query system manager 502 can include the“shared.users-col” dataset 608D in the query configuration parameters1406 based on a determination that it is referenced by the“shared.users” dataset 608C.

In the illustrated embodiment, the query system manager 502 determinesthat the datasets “shared.main,” “shared.users,” “shared.users-col,”“trafficTeam.threats,” and “trafficTeam.threat-col” are primarydatasets. Accordingly, the query system manager 502 includes the datasetconfiguration records 604 corresponding to the identified primarydatasets as part of the query configuration parameters 1406. Similarly,the query system manager 502 determines that the “shared.X” rule isassociated with the query and/or will be used to process/execute thequery and includes the corresponding rule configuration record 606 aspart of the query configuration parameters 1406.

In the illustrated embodiment, the query to be executed by the dataintake and query system 108 corresponds to the system query 1404,however, it will be understood that in other embodiments, the querysystem manager 502 may identify the query configuration parameters 1406for the query and may not translate the user query to the system query1404. Thus, the query configuration parameters 1406 can be used toexecute a system query, a user query, or some other query generated fromthe user query 1402.

As mentioned, in some embodiments, the metadata catalog 221 may notstore separate dataset association records 602. Rather, the datasetsassociation records 602 illustrated in FIG. 14 can be considered alogical association between one or more dataset configuration records604 and/or one or more rule configuration records 606. In certainembodiments, the datasets 608 and/or rules 610 of each datasetassociation record 602 may be references to dataset configurationrecords 604 and/or rule configuration records 606. Accordingly, in someembodiments, rather than moving from or parsing different portions of adataset association record 602, it will be understood that the querysystem manager 502 can parse different dataset configuration records 604and/or rule configuration records 606 based on the identified physicalidentifier for the dataset or rule. For example, (2) may refer toparsing the “trafficTeam.threats-encountered” dataset configurationrecord 604, (3A) and (3B) may refer to parsing the “trafficTeam.traffic”and “trafficTeam.threats” dataset configuration records 604,respectively, (4A) and (4B) may refer to parsing the“trafficTeam.threats-col” and “shared.main,” dataset configurationrecords 604, respectively, (4C) may refer to parsing the“trafficTeam.shared.X” (or “shared.X”) rule configuration record 606,(5) may refer to parsing the “shared.X” rule configuration record 606(or be combined with (4C)), (6) may refer to parsing the “shared.users”dataset configuration record 604, and (7) may refer to parsing the“shared.users-col” dataset configuration record 604. Thus, as the querysystem manager 502 parses different datasets 608 or rules 610, it can doso using the dataset configuration records 604 and rule configurationrecords 606, respectively. Moreover, in some such embodiments (8) may beomitted (or considered as part of each parsing step) as the query systemmanager 502 references the relevant dataset configuration records 604and rule configuration records 606 throughout the review or parsingprocess. Based on the review of the various dataset configurationrecords 604 and rule configuration records 606, the query system manager502 can (9) generate the system query 1404 and/or the queryconfiguration parameters 1406.

Furthermore, when parsing the dataset configuration records 604 or ruleconfiguration records 606, the system can use one or more annotations toidentify related datasets. For example, the system can determine thatthe “threats-encountered” dataset 608I depends on and/or is related tothe “traffic” dataset 608J and “threats” dataset 608H based on one ormore annotations, such as an inter-dataset relationship annotation, inthe dataset configuration record 604N. In some embodiments, using theannotations in the dataset configuration records 604, the system canmore quickly traverse between the different datasets and identify theprimary datasets for the query 1402.

In certain embodiments, as the system parses the query 1402, it canextract metadata and generate additional annotations for one or moredataset configuration records 604 and rule configuration records 606.For example, the query 1402 can be referred to as a dataset “job.” Basedon its reference to “threats-encountered,” the system can determine thatthe dataset “job” is dependent on “threats-encountered” and generate anannotation based on the determined relationship. The system can generateone or more additional annotations for the dataset “job” as describedherein. In some embodiments the annotations can be stored for future useor reference. For example, for each query that is entered, the systemcan generate a dataset configuration record 606 and store theannotations generated for the query.

In addition, if the system has not already generated annotations forother datasets referenced by the query (e.g., when the various datasetsare added to the metadata catalog 221), then the system can generateannotations as it traverses the datasets as part of parsing the query1402. For example, as described herein, the system can generateannotations for the dataset configuration record 604N indicating thatthe “threats-encountered” dataset 608I is dependent on the “traffic” and“threats” datasets 608H, 608J, respectively. As also described herein,the system can determine a relationship between the field “sig” of the“traffic” dataset 608J and the field “sig” of the “threats” dataset608H. Likewise, the system can determine inter-dataset relationshipsbetween the “traffic” and “main” datasets 608J and 608A, the“threats-col” and “threats” datasets 608G and 608H, and the “users” and“users-col” datasets 608C and 608D. In a similar way, the system candetermine a rule-dataset relationship between rule “X” 610A and dataset“users” 608C, etc. The system can use the various determinedrelationships to generate annotations for corresponding dataset and ruleconfiguration records 604, 606, respectively. In some embodiments, thegenerated annotations can be used to more efficiently parse and executethe query if it is executed again, to generate suggestions for the user,and/or to enable the user to gain a greater understanding of the dataassociated with, stored by, or managed by the system.

4.4.3. Metadata Catalog Flows

FIG. 15A is a flow diagram illustrative of an embodiment of a routineA1500 implemented by the query system 214 to execute a query. Althoughdescribed as being implemented by the query system 214, it will beunderstood that the elements outlined for routine B1500 can beimplemented by one or more computing devices/components that areassociated with the data intake and query system 108, such as, but notlimited to, the query system manager 502, the search head 504, thesearch master 512, the search manager 514, the search nodes 506, etc.Thus, the following illustrative embodiment should not be construed aslimiting.

At block A1502, a query system 214 receives a search query. As describedherein, the query system manager 502 can receive the query in a varietyof ways. For example, the query can be received via the gateway 215and/or network 208. The query can identify a set of data processing setof data. In addition, in some embodiments, the query can include one ormore commands to obtain data from a dataset, one or more datasetidentifiers, and/or a dataset association record identifier.

At block A1504, query system 214 identifies one or more primarydatasets. As described herein, the primary datasets can include one ormore source datasets and/or one or more datasets that are to be used toexecute the query. In some embodiments, to identify the source datasets,the query system 214 parses the query to identify the datasetidentifier(s) and/or the dataset association record identifier. Incertain embodiments, the query system 214 uses the dataset identifier(s)and/or the dataset association record identifier to identify the one ormore primary datasets.

In some embodiments, the query system 214 can iteratively process thedataset association record 602 associated with the identified datasetassociation record identifier to identify datasets associated with thequery and then identify primary datasets. For example, as describedherein, the query system 214 can parse one or more datasets of thedataset association record. For each dataset that is parsed, the querysystem 214 can determine whether the dataset is a source dataset or willotherwise be used to execute the query. If the query system 214determines that the dataset is a source dataset or will otherwise beused to execute the query, it can include the dataset as a primarydataset.

In certain embodiments, the query system 214 can use the datasetassociated with the dataset identifier to identify primary datasets. Forexample, the query system 214 can parse the dataset (or correspondingdataset configuration record 604) to determine whether the datasetincludes at least a portion of the set of data of the query (or is asource dataset), includes one or more query parameters to be included aspart of the query, references additional datasets (e.g., as part of aquery parameter and/or as part of being imported), and/or will be used(or its configuration parameters will be used) to execute the query.

Based on the parsing the query system 214 can determine whether thedataset is a primary dataset. In some embodiments, if the query systemdetermines that the dataset includes at least a portion of the set ofdata of the query, it can identify the dataset as a source dataset and aprimary dataset. In certain embodiments, if the dataset (or itsconfiguration parameters) will be used to execute the query, the querysystem 214 can determine that the dataset is a primary dataset. In somecases, if the dataset references other datasets (e.g., is a single ormulti-reference dataset), the query system 214 can parse the referenceddatasets to determine whether they are primary datasets. The querysystem 214 can iteratively process the datasets until any datasetreferenced by the query or referenced by another dataset that wasreferenced by the (directly or indirectly) query, has been processed. Ineach case, the query system 214 can determine whether the dataset is aprimary dataset. In certain embodiments, if the dataset includes one ormore query parameters and/or references one or more additional datasetsbut does not include at least a portion of the set of data or will notbe used as part of the query, the query system 214 can determine thatthe dataset is not a primary dataset or is a secondary dataset.

In certain embodiments, the query system 214 can also identify primaryrules, such as rules that will be used to process at least a portion ofthe set of data or process data from a primary dataset. In someembodiments, the query system 214 identifies the primary rules similarto identifying primary datasets. For example, the query system 214 canidentify one or more rules in the query and/or one or more rulesassociated with a dataset that is referenced in the query or isreferenced by another dataset that is referenced (directly orindirectly) by the query.

At A1506, the query system 214 generates query configuration parameters.In some cases, the query system 214 can generate the query configurationparameters based on one or more identified primary datasets and/orprimary rules. In certain embodiments, the query system 214 can generatethe query configuration parameters based on one or more dataset and/orquery configurations from a metadata catalog 221. For example, asdescribed herein, the metadata catalog 221 can include one or moredataset configuration records 604. In certain embodiments, the querysystem 214 includes the dataset configuration records 604 associatedwith the primary datasets in the query configuration parameters. Incertain embodiments, the query configuration parameters can include ruleconfiguration records 606 associated with the primary rules.

At A1508, the query system 214 executes the query. In some embodiments,the query system 214 executes the query based on the query configurationparameters. For example, the query configuration parameters can indicatehow to access the source datasets, how to process data from the sourcedatasets, etc. As described herein, the query system 214 can dynamicallydetermine the query configuration parameters for the query. In certainembodiments, the query system 214 determines the configurations toexecute the query using only the query configuration parametersidentified at block A1506. Furthermore, the query system 214 can executethe query, as described herein at least with reference to FIGS. 11-21.

Fewer, more, or different blocks can be used as part of the routineA1500. For example, in some embodiments, the query system 214 cangenerate a system query from a user query. In some cases, one or moreblocks can be omitted. In some embodiments, the blocks of routine A1500can be combined with any one or any combination of blocks describedherein with reference to at least FIGS. 10A-10D, 12A-12G, 15B-15G, and16A. Furthermore, it will be understood that the various blocksdescribed herein with reference to FIG. 15A can be implemented in avariety of orders, or can be performed concurrently. For example, theindexing node 404 can concurrently identify source datasets and obtainquery configuration parameters.

FIG. 15B is a flow diagram illustrative of an embodiment of a routineB1500 implemented by a query system manager 502 to communicate queryconfiguration parameters to a query processing component. Althoughdescribed as being implemented by the query system manager 502, it willbe understood that the elements outlined for routine B1500 can beimplemented by one or more computing devices/components that areassociated with the data intake and query system 108, such as, but notlimited to, query system 214, the search head 504, the search master512, the search manager 514, the search nodes 506, etc. Thus, thefollowing illustrative embodiment should not be construed as limiting.

At block B1502, the query system manager 502 receives a search query, asdescribed in greater detail above at least with reference to block A1502of FIG. 15A and (1′) of FIG. 13. At block B1504, query system manager502 identifies primary datasets, as described herein at least withreference to block A1504 of FIG. 15A and (2′) of FIG. 13. At B1506, thequery system manager 502 obtains query configuration parameters, asdescribed in greater detail above at least with reference to block A1506of FIG. 15A and (2′) of FIG. 13.

At B1508, the query system manager 502 communicates the queryconfiguration parameters to a query processing component, such as thesearch head 504. As described herein, the query processing component canprocess and execute the query using the received query configurationparameters. Further, as described herein, in some embodiments, the queryconfiguration parameters communicated to the query processing componentinclude only the query configuration parameters of the primary datasetand primary rules, which, in some embodiments, form a subset of thedataset configuration records 604 and rule configuration records 606 ofthe metadata catalog 221 and, in certain embodiments, form a subset ofthe dataset configuration records 604 and rule configuration records 606associated with the dataset association record(s) associated with thequery.

In some embodiments, the query processing component does not store queryconfiguration parameters. Accordingly, the search head 504 may beotherwise unable to process and execute the query without the queryconfiguration parameters received from the query system manager 502.Similarly, in some embodiments, the indexers and/or search nodes do notinclude query configuration parameters. Accordingly, in some suchembodiments, without the query configuration parameters received fromthe query system manager 502, the query system 214 would be unable toprocess and execute the query. Furthermore, by dynamically determiningand providing the query configuration parameters to the query processingcomponent, the query system 214 can provide a stateless query system.For example, if the query system 214 determines that multiple queryprocessing components are to be used to process the query or if anassigned query processing component becomes unavailable, the querysystem can communicate the query configuration parameters to anotherquery processing component without data loss.

Fewer, more, or different blocks can be used as part of the routineB1500. In some cases, one or more blocks can be omitted. In someembodiments, the blocks of routine B1500 can be combined with any one orany combination of blocks described herein with reference to at leastFIGS. 10A-10D, 12A-12G, 15A, 15C-15G, and 16A. Furthermore, it will beunderstood that the various blocks described herein with reference toFIG. 15B can be implemented in a variety of orders, or can be performedconcurrently. For example, the indexing node 404 can concurrentlyidentify source datasets and obtain query configuration parameters.

FIG. 15C is a flow diagram illustrative of an embodiment of a routineC1500 implemented by the query system 214 to execute a query. Althoughdescribed as being implemented by the search head 504, it will beunderstood that the elements outlined for routine C1500 can beimplemented by one or more computing devices/components that areassociated with the data intake and query system 108, such as, but notlimited to, the query system manager 502, the search master 512, thesearch manager 514, the search nodes 506, etc. Thus, the followingillustrative embodiment should not be construed as limiting.

At block C1502, the search head 504 receives a query. In someembodiments the query received by the search head 504 can be a systemquery generated by a query system manager 502. In certain embodiments,the query received by the search head 504 can correspond to a queryreceived by the query system 214 and/or a query received by the dataintake and query system 108.

At block C1504, the search head 504 receives query configurationparameters. As described herein, in some embodiments, the query systemmanager 502 dynamically identifies the query configuration parameters tobe used to process and execute query. The query configuration parameterscan include dataset configuration records 604 associated with primarydatasets and/or rule configuration records 606 associated with primaryrules. In some such embodiments, the search head 504 does not storequery configuration parameters locally. In certain embodiments, thequery configuration parameters are concurrently received with the query.Furthermore, as described herein, in some embodiments, the queryconfiguration parameters are dynamically generated at query time, or inother words are not determined prior to receipt of the query. In certainembodiments, the query configuration parameters correspond to a subsetof the configuration parameters associated with a dataset associationrecord and/or a metadata catalog 221.

In certain embodiments, by dynamically receiving the query configurationparameters associated with a query (or concurrently with the query), thequery system 214 can provide a stateless search experience. For example,if the search head 504 becomes unavailable, the query system manager 502can communicate the dynamically determined query configurationparameters (and/or query to be executed) to another search head 504without data loss and/or with minimal or reduced time loss. At blockC1506, the search head 504 executes the query, as described herein atleast with reference to block A1508 of FIG. 15A and FIGS. 11 and12A-12G.

Fewer, more, or different blocks can be used as part of the routineC1500. In some cases, one or more blocks can be omitted. In someembodiments, the blocks of routine B1500 can be combined with any one orany combination of blocks described herein with reference to at leastFIGS. 10A-10D, 12A-12G, 15A, 15B, 15D-15G, and 16A. Furthermore, it willbe understood that the various blocks described herein with reference toFIG. 15C can be implemented in a variety of orders, or can be performedconcurrently.

FIG. 15D is a flow diagram illustrative of an embodiment of a routineD1500 implemented by the query system 214 to execute a query. Althoughdescribed as being implemented by the query system manager 502, it willbe understood that the elements outlined for routine D1500 can beimplemented by one or more computing devices/components that areassociated with the data intake and query system 108, such as, but notlimited to, the search head 504, the search master 512, the searchmanager 514, the search nodes 506, etc. Thus, the following illustrativeembodiment should not be construed as limiting.

At block D1502, the query system manager 502 receives a user query, asdescribed herein at least with reference to (1′) of FIG. 13 and blockB1502 of FIG. 15B. At block D1504, the query system manager 502identifies one or more dataset association records. In some embodiments,the query system manager 502 identifies the more dataset associationrecords by parsing the user query and/or via command received with theuser query.

In certain embodiments, as described herein, the dataset associationrecords identify a subset of datasets of a plurality of datasets in ametadata catalog 221 and/or one or more rules for processing data fromat least one dataset of the subset of datasets. In certain embodiments,the datasets of a dataset association record include source datasets,datasets that reference additional datasets, and/or datasets thatreference one or more rules. In some embodiments, if the datasetreferences another dataset or rule, the query system manager 502 canrecursively analyze the referenced datasets and rules until itidentifies the primary datasets and primary rules. In certainembodiments, the query system manager 502 parses multiple datasetassociation records to identify primary datasets and/or primary rules.

At block D1506, the query system manager 502 generates a system query.In some embodiments, the query system manager 502 generates a systemquery based on the dataset association records identified at blockD1504. For example, using the dataset association records, the querysystem manager 502 can determine a physical identifier for primarydatasets and primary rules. The query system manager 502 can use thephysical dataset identifiers to generate the system query. For example,the query system manager 502 can reference the physical datasetidentifiers in the system query and/or remove all logical datasetidentifiers from the user query. In addition, as described herein, insome embodiments, datasets of a dataset association record 602 mayreference one or more query parameters. Accordingly, in certainembodiments, the query system manager 502 can include the queryparameters referenced by a dataset in the system query.

Furthermore, using the dataset association records, the query systemmanager can identify one or more rules related to the source datasets.As described herein, in certain embodiments, the query system manager502 analyzes multiple dataset association records to identify datasetsassociated with the query.

At block D1508, the query system manager 502 communicates the systemquery to a query execution component of the data intake and querysystem. In certain embodiments, query system manager 502 communicatesthe system query to a search head 504, as described herein at least withreference to the (4′) of FIG. 13. Furthermore, the query executioncomponent can process and execute the system query, as described hereinat least with reference to FIGS. 11-21.

Fewer, more, or different blocks can be used as part of the routineD1500. For example, the query system manager 502 can generate queryconfiguration parameters and communicate the query configurationparameters to the query execution component. In some cases, one or moreblocks can be omitted. In some embodiments, the blocks of routine D1500can be combined with any one or any combination of blocks describedherein with reference to at least FIGS. 10A-10D, 12A-12G, 15A-15C,15E-15G, and 16A. Furthermore, it will be understood that the variousblocks described herein with reference to FIG. 15D can be implemented ina variety of orders, or can be performed concurrently.

FIG. 15E is a flow diagram illustrative of an embodiment of a routineE1500 implemented by the query system 214 to execute a query. Althoughdescribed as being implemented by the query system manager 502, it willbe understood that the elements outlined for routine E1500 can beimplemented by one or more computing devices/components that areassociated with the data intake and query system 108, such as, but notlimited to, the search head 504, the search master 512, the searchmanager 514, the search nodes 506, etc. Thus, the following illustrativeembodiment should not be construed as limiting.

At block E1502, the query system manager 502 receives a user query, asdescribed in herein at least with reference to block D1502 of FIG. 15D.At block E1504, the query system manager 502 identifies one or moredatasets for a system query. As described herein, the query systemmanager 502 can identify the one or more datasets in a variety of ways.For example, the query system manager 502 can parse a query anditeratively parse one or more dataset association records 602, datasets,and/or dataset configuration records 604 associated with the query toidentify query parameters (including datasets) that are to be includedin the system query.

In some embodiments, a dataset to be included in a query can correspondsto a dataset referenced in the user query. For example, a user query mayidentify a “main” dataset (associated with a “test” dataset associationrecord) and the query system manager 502 can determine that the“test.main” dataset is to be included in the system query.

In certain embodiments, a dataset to be included in the system query cancorrespond to a dataset referenced by another datasets, such as a querydataset, an imported dataset, or another dataset etc. For example, auser query may reference a “findme” query dataset and the query systemmanager 502 can determine that a “myapp.test” dataset referenced(directly or indirectly) by the “findme” query dataset is to be includedin the system query. In some such cases, the dataset to be included inthe query can correspond to a query parameter of a query in a querydataset.

In certain cases, the dataset to be included in the system query caninclude a source dataset and/or a source reference dataset. For example,the system query can include a dataset that includes at least a portionof the data of the set of data to be searched and/or include a datasetthat refers to or is used to access the data of the set of data that isto be searched.

At block E1506 the query system manager 502 identifies a dataset type ofthe source datasets, as described herein at least with reference to (2′)of FIG. 13 and FIG. 14. For example, the query system manager 502 canuse one or more dataset association records 602 and/or datasetconfiguration records 604 to identify a dataset type of the datasets tobe included in the query. In certain cases, the query system manager 502can parse the identified dataset configuration records 604 to identifythe dataset type of the source datasets.

At block E1508, the query system manager 502 generates a system query,as described herein at least with reference to (3′) of FIG. 13 and FIG.14. In some embodiments, different commands can be associated withdifferent datasets. For example, an index dataset can be associated witha “search” command, a lookup dataset can be associated with a “lookup,”command, a metrics interaction dataset can be associated with an“mstats,” command, etc. Accordingly, based on the dataset type, thequery system manager 502 can determine a command to be used to search orretrieve data from the datasets identified for inclusion in the systemquery. The query system manager 502 can include the determined commandsfor the identified source dataset in the system query. Furthermore, insome embodiments, the query system manager 502 can determine a physicalidentifier for the datasets to be included in the system query andinclude the physical identifier for the datasets in the system query. Incertain embodiments, the query system manager 502 can identify one ormore query parameters of with a dataset associated with the query andinclude the query parameters in the system query.

At block E1510, the query system manager 502 communicates the systemquery to a query execution component of the data intake and querysystem, as described herein at least with reference to block D1508 ofFIG. 15D.

Fewer, more, or different blocks can be used as part of the routineE1500. For example, the query system manager 502 can generate queryconfiguration parameters and communicate the query configurationparameters to the query execution component. In some cases, one or moreblocks can be omitted. In some embodiments, the blocks of routine E1500can be combined with any one or any combination of blocks describedherein with reference to at least FIGS. 10A-10D, 12A-12G, 15A-15D, 15F,15G, and 16A. Furthermore, it will be understood that the various blocksdescribed herein with reference to FIG. 15E can be implemented in avariety of orders, or can be performed concurrently.

4.5. Annotating the Metadata Catalog

As described herein, the metadata catalog 221 can be automaticallyannotated based on system use or based on detected changes to themetadata catalog 221. The system can use the annotations to improve thequery times, reduce the amount of processing used to execute a query,generate suggestions for improved queries, and generate an understandingof the dataset associated with, stored by, or managed by the system,etc.

4.5.1. Annotations Based on Query Processing Flow

FIG. 15F is a flow diagram illustrative of an embodiment of a routineF1500 implemented by the system 108 to generate an annotation based onprocessing a query. Although described as being implemented by thesystem 108, it will be understood that the elements outlined for routineF1500 can be implemented by one or more computing devices/componentsthat are associated with the data intake and query system 108, such as,but not limited to, an indexing node 404, indexing system manager 402,the query system manager 502, the search head 504, the search master512, the search manager 514, the search nodes 506, etc. Thus, thefollowing illustrative embodiment should not be construed as limiting.

At block F1502, the system identifies a query. The system can identify aquery in a variety of ways. In some embodiments, the system can identifya query by parsing a dataset configuration record 604 that includes aquery, such as a dataset configuration record 604 associated with a viewdataset. In certain embodiments, the system can identify a query byreceiving a query from a user via a user interface. For example, a usermay enter a query for execution by the system 108 via the userinterface.

At block F1504, the system identifies one or more datasets associatedwith the query. As described herein, the system can identify thedatasets associated with the query by parsing the query. In parsing thequery, the system can use known syntax and semantics of the querylanguage to identify datasets explicitly recited in the query. Forexample, the system can use the syntax and semantics of the querylanguage to identify commands in the query and locations followingcommands where datasets are identified. The system can use the datasetsexplicitly identified in the query to identify additional datasetsassociated with the query. For example, the system can parse the datasetconfiguration records 604 of the identified datasets to identifyadditional datasets associated with the query The system can iterativelyprocess the datasets until any dataset referenced by the query orreferenced by another dataset that was referenced by the (directly orindirectly) query, has been parsed.

At block F1506, the system identifies one or more data fields associatedwith the query. The system can identify the one or more data fieldssimilar to the manner in which it identifies datasets. For example, thesystem can identify an initial group of data fields based on the syntaxand semantics of the query. The system can identify additional datafields based on the datasets identified at bloc F1504. For example, if afield is referenced by a dataset in connection with the query (e.g., aview dataset that is associated with the query identifies the fields aspart of a query of the view dataset), the system can identify the fieldsas being associated with the query. In certain embodiments, some fieldsassociated with the identified datasets are not identified as beingassociated with the query. For example, if a dataset configurationrecord 604 associated with an identified dataset indicates that thedataset has four fields, but only one of those fields is referenced byor will be used to execute the query, the system can identify the onefield as associated with the query and determine that the other threefields are not associated with the query.

At block F1508, the system generates one or more annotations. Theannotations can be based on the identified dataset and/or fields. Asdescribed herein, at least with reference to FIG. 6, the system cangenerate a variety of annotations. In some cases, the annotations cancorrespond to the identified datasets and fields. For example, thesystem can generate one more annotations identifying the one or morefields or datasets identified at block F1504 and F1506.

In certain embodiments, the annotations can correspond to one or moredetermined relationships between the identified fields and datasets. Forexample, as described herein, the system can generate an annotationidentifying one or more field-dataset relationships, inter-fieldrelationships, inter-dataset relationships, etc. In some embodiments,the system can determine an inter-dataset relationship based on the(direct or indirect) reference of one dataset to another dataset ormultiple datasets having the similar or same field. In certainembodiments, the system can determine an inter-field relationship basedon the presence of a field in multiple datasets or based on one fieldbeing derived from another field following one or more transformationsof data. Additional examples of annotations derived from parsing thequery are described herein at least with reference to FIG. 6.

In some embodiments, the annotations can correspond to one or moreusers. For example, the system can generate an annotation identifyingthe user (and/or group associated with the user) associated with thequery.

At block F1510, the system updates a metadata catalog 221 based at leastin part on the generated annotations. In some embodiments, the generatedannotations are stored and associated with one or more dataset or ruleconfiguration records 604, 606. In certain embodiments, the system 108can associate each annotation with a dataset. The annotation can bestored in the dataset configuration record 604 of the dataset orotherwise reference the dataset. For example, if an annotationidentifies a field or field-dataset relationship, the system 108 canstore the annotation and indicate the dataset related to the identifiedfield. As another example, if an annotation identifies an inter-fieldrelationship, the system can store the annotation indicating the relatedfields and associated datasets. Similarly, if an annotation identifiesan inter-dataset relationship, the system can store the annotationindicating the related datasets.

Fewer, more, or different blocks can be used as part of the routineF1500. In some cases, one or more blocks can be omitted. For example, insome cases, the routine F1500 can exclude block F1504 or F1506. In someembodiments, the blocks of routine F1500 can be combined with any one orany combination of blocks described herein with reference to at leastFIGS. 10A-10D, 12A-12G, 15A-15E, 15G, and 16A. For example, the systemcan execute routine F1500 as part of processing or executing a query orcan use the annotations generated as a result of routine F1500 toprocess additional queries. Similarly, in response to updating themetadata catalog 221, the system can execute one or more blocks ofroutine G1500 to generate one or more additional annotations.

In some embodiments, the routine F1500 further includes using theannotations to generate additional annotations, propagating one or moreannotations from one dataset to another dataset, suggesting one or moredatasets or fields to a user or group.

In certain embodiments, the routine F1500 further includes monitoringthe system during execution of the query and generating one or moreannotations based on the monitoring. For example, the system can monitorthe amount of data obtained from a dataset, the time to obtain data froma dataset source, an estimated size of a dataset source, etc. andgenerate corresponding annotations. Moreover, the routine F1500 canfurther include generating one or more cost-based optimizations based onthe annotations. In some cases, the system can generate the cost-basedoptimizations as part of processing a query for execution.

Furthermore, it will be understood that the various blocks describedherein with reference to FIG. 15F can be implemented in a variety oforders, or can be performed concurrently. For example, the system canconcurrently identify datasets, identify fields, generate annotations,and update the metadata catalog 221. For example, as each new dataset isidentified, the system can generate annotations associated with thedataset and update the metadata catalog 221 for that dataset whileconcurrently identifying additional datasets and/or fields.

4.5.2. Annotations Based on Catalog Changes Flow

FIG. 15G is a flow diagram illustrative of an embodiment of a routineG1500 implemented by the system 108 to generate an annotation based on achange to the metadata catalog 221. Although described as beingimplemented by the system 108, it will be understood that the elementsoutlined for routine G1500 can be implemented by one or more computingdevices/components that are associated with the data intake and querysystem 108, such as, but not limited to, the query system manager 502,the search head 504, the search master 512, the search manager 514, thesearch nodes 506, etc. Thus, the following illustrative embodimentshould not be construed as limiting.

At block G1502, the system identifies a change to the metadata catalog221 based at least in part on a first annotation. As described herein atleast with reference to FIG. 6, the metadata catalog 221 can identify avariety of datasets and store dataset configuration records 604 for thedifferent datasets. The dataset configuration records 604 can include orbe associated with annotations that correspond to the dataset.Similarly, the annotations can identify a dataset and/or field withwhich they are associated. Accordingly, the identified change cancorrespond to the addition of the first annotation to the metadatacatalog 221 or a change made to the first annotation.

As described herein, the annotations of the metadata catalog 221(including the first annotation) can correspond to user annotationsadded by a user or system annotations generated by the system. In somecases, the first annotation can correspond to an annotation generated inresponse to parsing a query, such as an annotation generated as a resultof routine F1500, an annotation generated in response to monitoring theexecution of a query, an annotation generated in response to monitoringa user or program executing in the system, or an annotation generated inresponse to another annotation.

In addition, as described herein, the annotations can identify any oneor any combination of field-dataset relationships, inter-fieldrelationships, inter-dataset relationships, number of fields in adataset, field usage (total, by dataset, by user, by group, etc.),popular fields of a dataset, dataset usage (total, by user, by group,etc.), popular datasets, alarm thresholds, data categories, users orgroups associated with a dataset or field, units or preferred unitsassociated with a dataset or field, among others.

At block G1504, in response to identifying the change, the systemgenerates a second annotation for the metadata catalog 221 based atleast in part on the first annotation.

As described herein, the second annotation can be generated for the samedataset that is associated with the first annotation or a seconddataset. Accordingly, in some embodiments, as part of generating asecond annotation, the system identifies a second dataset that isrelated to the first dataset and to which the second annotation will beassociated.

For example if the first annotation is a field-dataset relationshipannotation, the second annotation can be an annotation that indicatesthe number of fields for the first dataset (updated based on the newfield-dataset relationship annotation), or an inter-dataset relationshipannotation identifying a second dataset that is similar to the firstdataset or a second dataset to which the first dataset can be mapped. Asanother example, if the first annotation is an inter-field orinter-dataset relationship annotation, the second annotation can beanother inter-field or inter-dataset relationship annotation, apropagated alarm threshold annotation, a propagated data categoryannotation, or a propagated unit or preferred unit annotation. Asanother example, if the first annotation is a field, dataset, orapplication annotation, the second annotation can be a number of uses orpopularity annotation. As yet another example, if the first annotationis an alarm threshold, unit/preferred unit, or data category annotationassociated with the first dataset, the second annotation can be an alarmthreshold, unit/preferred unit, or data category annotation associatedwith a second dataset that is related to the first dataset. Additionalexamples of second annotations that can be generated based on firstannotations is described herein at least with reference to FIG. 6.

At block G1506, the system updates the metadata catalog 221 based atleast in part on the second annotation. Similar to block F1510 ofroutine F1500, the generated annotation can be stored and associatedwith one or more dataset or rule configuration records 604, 606.

Fewer, more, or different blocks can be used as part of the routineG1500. In some cases, one or more blocks can be omitted. For example,the blocks of routine G1500 can be combined with any one or anycombination of blocks described herein with reference to at least FIGS.10A-10D, 12A-12G, 15A-15F, and 16A. For example, system 108 can executeroutine G1500 in response to updating the metadata catalog 221 asdescribed herein at least with reference to FIG. 15F.

In some embodiments, routine G1500 can be repeated based on generatedannotations. For example, if a first annotation is generated the firsttime system executes routine G1500, the system 108 can execute routineG1500 based on the first annotation to generate a second annotation,until the system 108 determines that no more annotations are to begenerated. In some embodiments, the system 108 can use multipleprocesses (e.g., processes, threads, or isolated execution environments)to execute multiple versions of routine G1500 concurrently. For example,one process can monitor for changes related to fields in the metadatacatalog 221 and generate annotations based on the detected fieldchanges, another process can monitor for changes related to datasets orinter-dataset relationships in the metadata catalog 221 and generateannotations based on the detected changes, and so forth. In this way,the system can concurrently generate different annotations for themetadata catalog 221.

Furthermore, it will be understood that the various blocks describedherein with reference to FIG. 15G can be implemented in a variety oforders, or can be performed concurrently. For example, the system canconcurrently identify datasets, generate multiple annotations, andupdate the metadata catalog 221. For example, multiple annotations maybe concurrently generated based on the first annotation.

4.6. Data Ingestion, Indexing, and Storage Flow

FIG. 16A is a flow diagram of an example method that illustrates how adata intake and query system 108 processes, indexes, and stores datareceived from data sources 202, in accordance with example embodiments.The data flow illustrated in FIG. 16A is provided for illustrativepurposes only; it will be understood that one or more of the steps ofthe processes illustrated in FIG. 16A may be removed or that theordering of the steps may be changed. Furthermore, for the purposes ofillustrating a clear example, one or more particular system componentsare described in the context of performing various operations duringeach of the data flow stages. For example, the intake system 210 isdescribed as receiving and processing machine data during an inputphase; the indexing system 212 is described as parsing and indexingmachine data during parsing and indexing phases; and a query system 214is described as performing a search query during a search phase.However, other system arrangements and distributions of the processingsteps across system components may be used.

4.6.1. Input

At block 1602, the intake system 210 receives data from an input source,such as a data source 202 shown in FIG. 2. The intake system 210initially may receive the data as a raw data stream generated by theinput source. For example, the intake system 210 may receive a datastream from a log file generated by an application server, from a streamof network data from a network device, or from any other source of data.In some embodiments, the intake system 210 receives the raw data and maysegment the data stream into messages, possibly of a uniform data size,to facilitate subsequent processing steps. The intake system 210 maythereafter process the messages in accordance with one or more rules, asdiscussed above for example with reference to FIGS. 7 and 8, to conductpreliminary processing of the data. In one embodiment, the processingconducted by the intake system 210 may be used to indicate one or moremetadata fields applicable to each message. For example, the intakesystem 210 may include metadata fields within the messages, or publishthe messages to topics indicative of a metadata field. These metadatafields may, for example, provide information related to a message as awhole and may apply to each event that is subsequently derived from thedata in the message. For example, the metadata fields may includeseparate fields specifying each of a host, a source, and a source typerelated to the message. A host field may contain a value identifying ahost name or IP address of a device that generated the data. A sourcefield may contain a value identifying a source of the data, such as apathname of a file or a protocol and port related to received networkdata. A source type field may contain a value specifying a particularsource type label for the data. Additional metadata fields may also beincluded during the input phase, such as a character encoding of thedata, if known, and possibly other values that provide informationrelevant to later processing steps.

At block 504, the intake system 210 publishes the data as messages on anoutput ingestion buffer 310. Illustratively, other components of thedata intake and query system 108 may be configured to subscribe tovarious topics on the output ingestion buffer 310, thus receiving thedata of the messages when published to the buffer 310.

4.6.2. Parsing

At block 1606, the indexing system 212 receives messages from the intakesystem 210 (e.g., by obtaining the messages from the output ingestionbuffer 310) and parses the data of the message to organize the data intoevents. In some embodiments, to organize the data into events, theindexing system 212 may determine a source type associated with eachmessage (e.g., by extracting a source type label from the metadatafields associated with the message, etc.) and refer to a source typeconfiguration corresponding to the identified source type. The sourcetype definition may include one or more properties that indicate to theindexing system 212 to automatically determine the boundaries within thereceived data that indicate the portions of machine data for events. Ingeneral, these properties may include regular expression-based rules ordelimiter rules where, for example, event boundaries may be indicated bypredefined characters or character strings. These predefined charactersmay include punctuation marks or other special characters including, forexample, carriage returns, tabs, spaces, line breaks, etc. If a sourcetype for the data is unknown to the indexing system 212, the indexingsystem 212 may infer a source type for the data by examining thestructure of the data. Then, the indexing system 212 can apply aninferred source type definition to the data to create the events.

At block 1608, the indexing system 212 determines a timestamp for eachevent. Similar to the process for parsing machine data, an indexingsystem 212 may again refer to a source type definition associated withthe data to locate one or more properties that indicate instructions fordetermining a timestamp for each event. The properties may, for example,instruct the indexing system 212 to extract a time value from a portionof data for the event, to interpolate time values based on timestampsassociated with temporally proximate events, to create a timestamp basedon a time the portion of machine data was received or generated, to usethe timestamp of a previous event, or use any other rules fordetermining timestamps.

At block 1610, the indexing system 212 associates with each event one ormore metadata fields including a field containing the timestampdetermined for the event. In some embodiments, a timestamp may beincluded in the metadata fields. These metadata fields may include anynumber of “default fields” that are associated with all events, and mayalso include one more custom fields as defined by a user. Similar to themetadata fields associated with the data blocks at block 1604, thedefault metadata fields associated with each event may include a host,source, and source type field including or in addition to a fieldstoring the timestamp.

At block 1612, the indexing system 212 may optionally apply one or moretransformations to data included in the events created at block 1606.For example, such transformations can include removing a portion of anevent (e.g., a portion used to define event boundaries, extraneouscharacters from the event, other extraneous text, etc.), masking aportion of an event (e.g., masking a credit card number), removingredundant portions of an event, etc. The transformations applied toevents may, for example, be specified in one or more configuration filesand referenced by one or more source type definitions.

FIG. 16C illustrates an illustrative example of how machine data can bestored in a data store in accordance with various disclosed embodiments.In other embodiments, machine data can be stored in a flat file in acorresponding bucket with an associated index file, such as a timeseries index or “TSIDX.” As such, the depiction of machine data andassociated metadata as rows and columns in the table of FIG. 16C ismerely illustrative and is not intended to limit the data format inwhich the machine data and metadata is stored in various embodimentsdescribed herein. In one particular embodiment, machine data can bestored in a compressed or encrypted formatted. In such embodiments, themachine data can be stored with or be associated with data thatdescribes the compression or encryption scheme with which the machinedata is stored. The information about the compression or encryptionscheme can be used to decompress or decrypt the machine data, and anymetadata with which it is stored, at search time.

As mentioned above, certain metadata, e.g., host 1636, source 1637,source type 1638 and timestamps 1635 can be generated for each event,and associated with a corresponding portion of machine data 1639 whenstoring the event data in a data store, e.g., data store 208. Any of themetadata can be extracted from the corresponding machine data, orsupplied or defined by an entity, such as a user or computer system. Themetadata fields can become part of or stored with the event. Note thatwhile the time-stamp metadata field can be extracted from the raw dataof each event, the values for the other metadata fields may bedetermined by the indexing system 212 or indexing node 404 based oninformation it receives pertaining to the source of the data separatefrom the machine data.

While certain default or user-defined metadata fields can be extractedfrom the machine data for indexing purposes, all the machine data withinan event can be maintained in its original condition. As such, inembodiments in which the portion of machine data included in an event isunprocessed or otherwise unaltered, it is referred to herein as aportion of raw machine data. In other embodiments, the port of machinedata in an event can be processed or otherwise altered. As such, unlesscertain information needs to be removed for some reasons (e.g.extraneous information, confidential information), all the raw machinedata contained in an event can be preserved and saved in its originalform. Accordingly, the data store in which the event records are storedis sometimes referred to as a “raw record data store.” The raw recorddata store contains a record of the raw event data tagged with thevarious default fields.

In FIG. 16C, the first three rows of the table represent events 1631,1632, and 1633 and are related to a server access log that recordsrequests from multiple clients processed by a server, as indicated byentry of “access.log” in the source column 1637.

In the example shown in FIG. 16C, each of the events 1631-1633 isassociated with a discrete request made from a client device. The rawmachine data generated by the server and extracted from a server accesslog can include the IP address 1640 of the client, the user id 1641 ofthe person requesting the document, the time 1642 the server finishedprocessing the request, the request line 1643 from the client, thestatus code 1644 returned by the server to the client, the size of theobject 1645 returned to the client (in this case, the gif file requestedby the client) and the time spent 1646 to serve the request inmicroseconds. As seen in FIG. 16C, all the raw machine data retrievedfrom the server access log is retained and stored as part of thecorresponding events, 1631-1633 in the data store.

Event 1634 is associated with an entry in a server error log, asindicated by “error.log” in the source column 1637 that records errorsthat the server encountered when processing a client request. Similar tothe events related to the server access log, all the raw machine data inthe error log file pertaining to event 1634 can be preserved and storedas part of the event 1634.

Saving minimally processed or unprocessed machine data in a data storeassociated with metadata fields in the manner similar to that shown inFIG. 16C is advantageous because it allows search of all the machinedata at search time instead of searching only previously specified andidentified fields or field-value pairs. As mentioned above, because datastructures used by various embodiments of the present disclosuremaintain the underlying raw machine data and use a late-binding schemafor searching the raw machines data, it enables a user to continueinvestigating and learn valuable insights about the raw data. In otherwords, the user is not compelled to know about all the fields ofinformation that will be needed at data ingestion time. As a user learnsmore about the data in the events, the user can continue to refine thelate-binding schema by defining new extraction rules, or modifying ordeleting existing extraction rules used by the system.

4.6.3. Indexing

At blocks 1614 and 1616, the indexing system 212 can optionally generatea keyword index to facilitate fast keyword searching for events. Tobuild a keyword index, at block 1614, the indexing system 212 identifiesa set of keywords in each event. At block 1616, the indexing system 212includes the identified keywords in an index, which associates eachstored keyword with reference pointers to events containing that keyword(or to locations within events where that keyword is located, otherlocation identifiers, etc.). When the data intake and query system 108subsequently receives a keyword-based query, the query system 214 canaccess the keyword index to quickly identify events containing thekeyword.

In some embodiments, the keyword index may include entries for fieldname-value pairs found in events, where a field name-value pair caninclude a pair of keywords connected by a symbol, such as an equals signor colon. This way, events containing these field name-value pairs canbe quickly located. In some embodiments, fields can automatically begenerated for some or all of the field names of the field name-valuepairs at the time of indexing. For example, if the string“dest=10.0.1.2” is found in an event, a field named “dest” may becreated for the event, and assigned a value of “10.0.1.2”.

At block 1618, the indexing system 212 stores the events with anassociated timestamp in a local data store 412 and/or common storage216. Timestamps enable a user to search for events based on a timerange. In some embodiments, the stored events are organized into“buckets,” where each bucket stores events associated with a specifictime range based on the timestamps associated with each event. Thisimproves time-based searching, as well as allows for events with recenttimestamps, which may have a higher likelihood of being accessed, to bestored in a faster memory to facilitate faster retrieval. For example,buckets containing the most recent events can be stored in flash memoryrather than on a hard disk. In some embodiments, each bucket may beassociated with an identifier, a time range, and a size constraint.

The indexing system 212 may be responsible for storing the eventscontained in various data stores 218 of common storage 216. Bydistributing events among the data stores in common storage 216, thequery system 214 can analyze events for a query in parallel. Forexample, using map-reduce techniques, each search node 506 can returnpartial responses for a subset of events to a search head that combinesthe results to produce an answer for the query. By storing events inbuckets for specific time ranges, the indexing system 212 may furtheroptimize the data retrieval process by enabling search nodes 506 tosearch buckets corresponding to time ranges that are relevant to aquery. In some embodiments, each bucket may be associated with anidentifier, a time range, and a size constraint. In certain embodiments,a bucket can correspond to a file system directory and the machine data,or events, of a bucket can be stored in one or more files of the filesystem directory. The file system directory can include additionalfiles, such as one or more inverted indexes, high performance indexes,permissions files, configuration files, etc.

In some embodiments, each indexing node 404 (e.g., the indexer 410 ordata store 412) of the indexing system 212 has a home directory and acold directory. The home directory stores hot buckets and warm buckets,and the cold directory stores cold buckets. A hot bucket is a bucketthat is capable of receiving and storing events. A warm bucket is abucket that can no longer receive events for storage but has not yetbeen moved to the cold directory. A cold bucket is a bucket that can nolonger receive events and may be a bucket that was previously stored inthe home directory. The home directory may be stored in faster memory,such as flash memory, as events may be actively written to the homedirectory, and the home directory may typically store events that aremore frequently searched and thus are accessed more frequently. The colddirectory may be stored in slower and/or larger memory, such as a harddisk, as events are no longer being written to the cold directory, andthe cold directory may typically store events that are not as frequentlysearched and thus are accessed less frequently. In some embodiments, anindexing node 404 may also have a quarantine bucket that contains eventshaving potentially inaccurate information, such as an incorrect timestamp associated with the event or a time stamp that appears to be anunreasonable time stamp for the corresponding event. The quarantinebucket may have events from any time range; as such, the quarantinebucket may always be searched at search time. Additionally, an indexingnode 404 may store old, archived data in a frozen bucket that is notcapable of being searched at search time. In some embodiments, a frozenbucket may be stored in slower and/or larger memory, such as a harddisk, and may be stored in offline and/or remote storage.

In some embodiments, an indexing node 404 may not include a colddirectory and/or cold or frozen buckets. For example, as warm bucketsand/or merged buckets are copied to common storage 216, they can bedeleted from the indexing node 404. In certain embodiments, one or moredata stores 218 of the common storage 216 can include a home directorythat includes warm buckets copied from the indexing nodes 404 and a colddirectory of cold or frozen buckets as described above.

Moreover, events and buckets can also be replicated across differentindexing nodes 404 and data stores 218 of the common storage 216.

FIG. 11B is a block diagram of an example data store 1101 that includesa directory for each index (or partition) that contains a portion ofdata stored in the data store 1101, and a sub-directory for one or morebuckets of the index. FIG. 11B further illustrates details of anembodiment of an inverted index 1107B and an event reference array 1115associated with inverted index 1107B.

The data store 1101 can correspond to a data store 218 that storesevents in common storage 216, a data store 412 associated with anindexing node 404, or a data store associated with a search node 506. Inthe illustrated embodiment, the data store 1101 includes a _maindirectory 1103A associated with a _main partition and a _test directory1103B associated with a _test partition. However, the data store 1101can include fewer or more directories. In some embodiments, multipleindexes can share a single directory or all indexes can share a commondirectory. Additionally, although illustrated as a single data store1101, it will be understood that the data store 1101 can be implementedas multiple data stores storing different portions of the informationshown in FIG. 11B. For example, a single index or partition can spanmultiple directories or multiple data stores, and can be indexed orsearched by multiple search nodes 506.

Furthermore, although not illustrated in FIG. 11B, it will be understoodthat, in some embodiments, the data store 1101 can include directoriesfor each tenant and sub-directories for each partition of each tenant,or vice versa. Accordingly, the directories 1103A and 1103B illustratedin FIG. 11B can, in certain embodiments, correspond to sub-directoriesof a tenant or include sub-directories for different tenants.

In the illustrated embodiment of FIG. 16B, two sub-directories 1605A,1605B of the _main directory 1603A and one sub-directory 1603C of the_test directory 1603B are shown. The sub-directories 1605A, 1605B, 1605Ccan correspond to buckets of the partitions associated with thedirectories 1603A, 1603B. For example, the sub-directories 1605A and1605B can correspond to buckets “B1” and “B2” of the partition “_main”and the sub-directory 1605C can correspond to bucket “B1” of thepartition “test.” Accordingly, even though there are two buckets “B1,”as each “B1” bucket associated with a different partition (andcorresponding directory 1603), the system 108 can uniquely identifythem.

Although illustrated as buckets “B1” and “B2,” it will be understoodthat the buckets (and/or corresponding sub-directories 1605) can benamed in a variety of ways. In certain embodiments, the bucket (orsub-directory) names can include information about the bucket. Forexample, the bucket name can include the name of the partition withwhich the bucket is associated, a time range of the bucket, etc.

As described herein, each bucket can have one or more files associatedwith it, including, but not limited to one or more raw machine datafiles, bucket summary files, filter files, inverted indexes, highperformance indexes, permissions files, configuration files, etc. In theillustrated embodiment of FIG. 16B, the files associated with aparticular bucket can be stored in the sub-directory corresponding tothe particular bucket. Accordingly, the files stored in thesub-directory 1605A can correspond to or be associated with bucket “B1,”of partition “_main,” the files stored in the sub-directory 1605B cancorrespond to or be associated with bucket “B2” of partition “_main,”and the files stored in the sub-directory 1605C can correspond to or beassociated with bucket “B1” of partition “_test.”

In the illustrated embodiment of FIG. 16B, each sub-directory1605A-1605C of the partition-specific directories 1603A and 1603Bincludes an inverted index 1607A, 1607B, 1607C, respectively(generically referred to as inverted index(es) 1607). The invertedindexes 1607 can be keyword indexes or field-value pair indexesdescribed herein and can include less or more information than depictedin FIG. 16B.

In some embodiments, the inverted indexes 1607 can correspond todistinct time-series buckets stored in common storage 216, a search node506, or an indexing node 404 and that contains events corresponding tothe relevant partition (e.g., _main partition, _test partition). Assuch, each inverted index 1607 can correspond to a particular range oftime for a partition. In the illustrated embodiment of FIG. 16B, eachinverted index 1607 corresponds to the bucket associated with thesub-directory 1603 in which the inverted index 1607 is located. In someembodiments, an inverted index 1607 can correspond to multipletime-series buckets (e.g., include information related to multiplebuckets) or inverted indexes 1607 can correspond to a single time-seriesbucket.

In the illustrated embodiment of FIG. 16B, each sub-directory 1605includes additional files. In the illustrated embodiment, the additionalfiles include raw data files 1608A-1608C, high performance indexes1609A-1609C, and filter files 1610A-1610C. However, it will beunderstood that each bucket can be associated with fewer or more filesand each sub-directory can store fewer or more files.

Each inverted index 1607 can include one or more entries, such askeyword (or token) entries or field-value pair entries. Furthermore, incertain embodiments, the inverted indexes 1607 can include additionalinformation, such as a time range 1623 associated with the invertedindex or a partition identifier 1625 identifying the partitionassociated with the inverted index 1607. It will be understood that eachinverted index 1607 can include less or more information than depicted.

Token entries, such as token entries 1611 illustrated in inverted index1607B, can include a token 1611A (e.g., “error,” “itemID,” etc.) andevent references 1611B indicative of events that include the token. Forexample, for the token “error,” the corresponding token entry includesthe token “error” and an event reference, or unique identifier, for eachevent stored in the corresponding time-series bucket that includes thetoken “error.” In the illustrated embodiment of FIG. 16B, the errortoken entry includes the identifiers 3, 5, 6, 8, 11, and 12corresponding to events located in the time-series bucket associatedwith the inverted index 1607B that is stored in common storage 216, asearch node 506, or an indexing node 404 and is associated with thepartition “_main,” which in turn is associated with the directory 1103A.

In some cases, some token entries can be default entries, automaticallydetermined entries, or user specified entries. In some embodiments, theindexing system 212 can identify each word or string in an event as adistinct token and generate a token entry for the identified word orstring. In some cases, the indexing system 212 can identify thebeginning and ending of tokens based on punctuation, spaces, asdescribed in greater detail herein. In certain cases, the indexingsystem 212 can rely on user input or a configuration file to identifytokens for token entries 1611, etc. It will be understood that anycombination of token entries can be included as a default, automaticallydetermined, or included based on user-specified criteria.

Similarly, field-value pair entries, such as field-value pair entries1613 shown in inverted index 1607B, can include a field-value pair 1613Aand event references 1613B indicative of events that include a fieldvalue that corresponds to the field-value pair. For example, for afield-value pair sourcetype::sendmail, a field-value pair entry caninclude the field-value pair sourcetype::sendmail and a uniqueidentifier, or event reference, for each event stored in thecorresponding time-series bucket that includes a sendmail sourcetype.

In some cases, the field-value pair entries 1613 can be default entries,automatically determined entries, or user specified entries. As anon-limiting example, the field-value pair entries for the fields host,source, and sourcetype can be included in the inverted indexes 1607 as adefault. As such, all of the inverted indexes 1607 can includefield-value pair entries for the fields host, source, sourcetype. As yetanother non-limiting example, the field-value pair entries for theIP_address field can be user specified and may only appear in theinverted index 1607B based on user-specified criteria. As anothernon-limiting example, as the indexing system 212 indexes the events, itcan automatically identify field-value pairs and create field-value pairentries. For example, based on the indexing system's 212 review ofevents, it can identify IP_address as a field in each event and add theIP_address field-value pair entries to the inverted index 1607B. It willbe understood that any combination of field-value pair entries can beincluded as a default, automatically determined, or included based onuser-specified criteria.

With reference to the event reference array 1615, each unique identifier1617, or event reference, can correspond to a unique event located inthe time series bucket. However, the same event reference can be locatedin multiple entries of an inverted index. For example if an event has asourcetype “splunkd,” host “www1” and token “warning,” then the uniqueidentifier for the event will appear in the field-value pair entriessourcetype::splunkd and host::www1, as well as the token entry“warning.” With reference to the illustrated embodiment of FIG. 16B andthe event that corresponds to the event reference 3, the event reference3 is found in the field-value pair entries 1613 host::hostA, source::sourceB, source e::sourcetypeA, and IP_address::91.205.189.15 indicatingthat the event corresponding to the event references is from hostA,sourceB, of sourcetypeA, and includes 91.205.189.15 in the event data.

For some fields, the unique identifier is located in only onefield-value pair entry for a particular field. For example, the invertedindex may include four sourcetype field-value pair entries correspondingto four different sourcetypes of the events stored in a bucket (e.g.,sourcetypes: sendmail, splunkd, web_access, and web_service). Withinthose four sourcetype field-value pair entries, an identifier for aparticular event may appear in only one of the field-value pair entries.With continued reference to the example illustrated embodiment of FIG.16B, since the event reference 7 appears in the field-value pair entrysource e::sourcetypeA, then it does not appear in the other field-valuepair entries for the sourcetype field, includingsourcetype::sourcetypeB, source e::sourcetypeC, andsourcetype::sourcetypeD.

The event references 1617 can be used to locate the events in thecorresponding bucket. For example, the inverted index can include, or beassociated with, an event reference array 1615. The event referencearray 1615 can include an array entry 1617 for each event reference inthe inverted index 1607B. Each array entry 1617 can include locationinformation 1619 of the event corresponding to the unique identifier(non-limiting example: seek address of the event), a timestamp 1621associated with the event, or additional information regarding the eventassociated with the event reference, etc.

For each token entry 1611 or field-value pair entry 1613, the eventreference 1601B or unique identifiers can be listed in chronologicalorder or the value of the event reference can be assigned based onchronological data, such as a timestamp associated with the eventreferenced by the event reference. For example, the event reference 1 inthe illustrated embodiment of FIG. 16B can correspond to thefirst-in-time event for the bucket, and the event reference 12 cancorrespond to the last-in-time event for the bucket. However, the eventreferences can be listed in any order, such as reverse chronologicalorder, ascending order, descending order, or some other order, etc.Further, the entries can be sorted. For example, the entries can besorted alphabetically (collectively or within a particular group), byentry origin (e.g., default, automatically generated, user-specified,etc.), by entry type (e.g., field-value pair entry, token entry, etc.),or chronologically by when added to the inverted index, etc. In theillustrated embodiment of FIG. 16B, the entries are sorted first byentry type and then alphabetically.

As a non-limiting example of how the inverted indexes 1607 can be usedduring a data categorization request command, the query system 214 canreceive filter criteria indicating data that is to be categorized andcategorization criteria indicating how the data is to be categorized.Example filter criteria can include, but is not limited to, indexes (orpartitions), hosts, sources, sourcetypes, time ranges, field identifier,tenant and/or user identifiers, keywords, etc.

Using the filter criteria, the query system 214 identifies relevantinverted indexes to be searched. For example, if the filter criteriaincludes a set of partitions (also referred to as indexes), the querysystem 214 can identify the inverted indexes stored in the directorycorresponding to the particular partition as relevant inverted indexes.Other means can be used to identify inverted indexes associated with apartition of interest. For example, in some embodiments, the querysystem 214 can review an entry in the inverted indexes, such as apartition-value pair entry 1613 to determine if a particular invertedindex is relevant. If the filter criteria does not identify anypartition, then the query system 214 can identify all inverted indexesmanaged by the query system 214 as relevant inverted indexes.

Similarly, if the filter criteria includes a time range, the querysystem 214 can identify inverted indexes corresponding to buckets thatsatisfy at least a portion of the time range as relevant invertedindexes. For example, if the time range is last hour then the querysystem 214 can identify all inverted indexes that correspond to bucketsstoring events associated with timestamps within the last hour asrelevant inverted indexes.

When used in combination, an index filter criterion specifying one ormore partitions and a time range filter criterion specifying aparticular time range can be used to identify a subset of invertedindexes within a particular directory (or otherwise associated with aparticular partition) as relevant inverted indexes. As such, the querysystem 214 can focus the processing to only a subset of the total numberof inverted indexes in the data intake and query system 108.

Once the relevant inverted indexes are identified, the query system 214can review them using any additional filter criteria to identify eventsthat satisfy the filter criteria. In some cases, using the knownlocation of the directory in which the relevant inverted indexes arelocated, the query system 214 can determine that any events identifiedusing the relevant inverted indexes satisfy an index filter criterion.For example, if the filter criteria includes a partition main, then thequery system 214 can determine that any events identified using invertedindexes within the partition main directory (or otherwise associatedwith the partition main) satisfy the index filter criterion.

Furthermore, based on the time range associated with each invertedindex, the query system 214 can determine that any events identifiedusing a particular inverted index satisfies a time range filtercriterion. For example, if a time range filter criterion is for the lasthour and a particular inverted index corresponds to events within a timerange of 50 minutes ago to 35 minutes ago, the query system 214 candetermine that any events identified using the particular inverted indexsatisfy the time range filter criterion. Conversely, if the particularinverted index corresponds to events within a time range of 59 minutesago to 62 minutes ago, the query system 214 can determine that someevents identified using the particular inverted index may not satisfythe time range filter criterion.

Using the inverted indexes, the query system 214 can identify eventreferences (and therefore events) that satisfy the filter criteria. Forexample, if the token “error” is a filter criterion, the query system214 can track all event references within the token entry “error.”Similarly, the query system 214 can identify other event referenceslocated in other token entries or field-value pair entries that matchthe filter criteria. The system can identify event references located inall of the entries identified by the filter criteria. For example, ifthe filter criteria include the token “error” and field-value pairsourcetype::web_ui, the query system 214 can track the event referencesfound in both the token entry “error” and the field-value pair entrysourcetype::web_ui. As mentioned previously, in some cases, such as whenmultiple values are identified for a particular filter criterion (e.g.,multiple sources for a source filter criterion), the system can identifyevent references located in at least one of the entries corresponding tothe multiple values and in all other entries identified by the filtercriteria. The query system 214 can determine that the events associatedwith the identified event references satisfy the filter criteria.

In some cases, the query system 214 can further consult a timestampassociated with the event reference to determine whether an eventsatisfies the filter criteria. For example, if an inverted indexcorresponds to a time range that is partially outside of a time rangefilter criterion, then the query system 214 can consult a timestampassociated with the event reference to determine whether thecorresponding event satisfies the time range criterion. In someembodiments, to identify events that satisfy a time range, the querysystem 214 can review an array, such as the event reference array 1615that identifies the time associated with the events. Furthermore, asmentioned above using the known location of the directory in which therelevant inverted indexes are located (or other partition identifier),the query system 214 can determine that any events identified using therelevant inverted indexes satisfy the index filter criterion.

In some cases, based on the filter criteria, the query system 214reviews an extraction rule. In certain embodiments, if the filtercriteria includes a field name that does not correspond to a field-valuepair entry in an inverted index, the query system 214 can review anextraction rule, which may be located in a configuration file, toidentify a field that corresponds to a field-value pair entry in theinverted index.

For example, the filter criteria includes a field name “sessionID” andthe query system 214 determines that at least one relevant invertedindex does not include a field-value pair entry corresponding to thefield name sessionID, the query system 214 can review an extraction rulethat identifies how the sessionID field is to be extracted from aparticular host, source, or sourcetype (implicitly identifying theparticular host, source, or sourcetype that includes a sessionID field).The query system 214 can replace the field name “sessionID” in thefilter criteria with the identified host, source, or sourcetype. In somecases, the field name “sessionID” may be associated with multipleshosts, sources, or sourcetypes, in which case, all identified hosts,sources, and sourcetypes can be added as filter criteria. In some cases,the identified host, source, or sourcetype can replace or be appended toa filter criterion, or be excluded. For example, if the filter criteriaincludes a criterion for source S1 and the “sessionID” field is found insource S2, the source S2 can replace S1 in the filter criteria, beappended such that the filter criteria includes source S1 and source S2,or be excluded based on the presence of the filter criterion source S1.If the identified host, source, or sourcetype is included in the filtercriteria, the query system 214 can then identify a field-value pairentry in the inverted index that includes a field value corresponding tothe identity of the particular host, source, or sourcetype identifiedusing the extraction rule.

Once the events that satisfy the filter criteria are identified, thequery system 214 can categorize the results based on the categorizationcriteria. The categorization criteria can include categories forgrouping the results, such as any combination of partition, source,sourcetype, or host, or other categories or fields as desired.

The query system 214 can use the categorization criteria to identifycategorization criteria-value pairs or categorization criteria values bywhich to categorize or group the results. The categorizationcriteria-value pairs can correspond to one or more field-value pairentries stored in a relevant inverted index, one or more partition-valuepairs based on a directory in which the inverted index is located or anentry in the inverted index (or other means by which an inverted indexcan be associated with a partition), or other criteria-value pair thatidentifies a general category and a particular value for that category.The categorization criteria values can correspond to the value portionof the categorization criteria-value pair.

As mentioned, in some cases, the categorization criteria-value pairs cancorrespond to one or more field-value pair entries stored in therelevant inverted indexes. For example, the categorizationcriteria-value pairs can correspond to field-value pair entries of host,source, and sourcetype (or other field-value pair entry as desired). Forinstance, if there are ten different hosts, four different sources, andfive different sourcetypes for an inverted index, then the invertedindex can include ten host field-value pair entries, four sourcefield-value pair entries, and five sourcetype field-value pair entries.The query system 214 can use the nineteen distinct field-value pairentries as categorization criteria-value pairs to group the results.

Specifically, the query system 214 can identify the location of theevent references associated with the events that satisfy the filtercriteria within the field-value pairs, and group the event referencesbased on their location. As such, the query system 214 can identify theparticular field value associated with the event corresponding to theevent reference. For example, if the categorization criteria includehost and sourcetype, the host field-value pair entries and sourcetypefield-value pair entries can be used as categorization criteria-valuepairs to identify the specific host and sourcetype associated with theevents that satisfy the filter criteria.

In addition, as mentioned, categorization criteria-value pairs cancorrespond to data other than the field-value pair entries in therelevant inverted indexes. For example, if partition or index is used asa categorization criterion, the inverted indexes may not includepartition field-value pair entries. Rather, the query system 214 canidentify the categorization criteria-value pair associated with thepartition based on the directory in which an inverted index is located,information in the inverted index, or other information that associatesthe inverted index with the partition, etc. As such a variety of methodscan be used to identify the categorization criteria-value pairs from thecategorization criteria.

Accordingly based on the categorization criteria (and categorizationcriteria-value pairs), the query system 214 can generate groupings basedon the events that satisfy the filter criteria. As a non-limitingexample, if the categorization criteria includes a partition andsourcetype, then the groupings can correspond to events that areassociated with each unique combination of partition and sourcetype. Forinstance, if there are three different partitions and two differentsourcetypes associated with the identified events, then the sixdifferent groups can be formed, each with a unique partitionvalue-sourcetype value combination. Similarly, if the categorizationcriteria includes partition, sourcetype, and host and there are twodifferent partitions, three sourcetypes, and five hosts associated withthe identified events, then the query system 214 can generate up tothirty groups for the results that satisfy the filter criteria. Eachgroup can be associated with a unique combination of categorizationcriteria-value pairs (e.g., unique combinations of partition valuesourcetype value, and host value).

In addition, the query system 214 can count the number of eventsassociated with each group based on the number of events that meet theunique combination of categorization criteria for a particular group (ormatch the categorization criteria-value pairs for the particular group).With continued reference to the example above, the query system 214 cancount the number of events that meet the unique combination ofpartition, sourcetype, and host for a particular group.

The query system 214, such as the search head 504 can aggregate thegroupings from the buckets, or search nodes 506, and provide thegroupings for display. In some cases, the groups are displayed based onat least one of the host, source, sourcetype, or partition associatedwith the groupings. In some embodiments, the query system 214 canfurther display the groups based on display criteria, such as a displayorder or a sort order as described in greater detail above.

As a non-limiting example and with reference to FIG. 16B, consider arequest received by the query system 214 that includes the followingfilter criteria: keyword=error, partition=main, time range=3/1/1716:22.00.000-16:28.00.000, sourcetype=sourcetypeC, host=hostB, and thefollowing categorization criteria: source.

Based on the above criteria, a search node 506 of the query system 214that is associated with the data store 1601 identifies _main directory1603 and can ignore _test directory 1605 and any otherpartition-specific directories. The search node 506 determines thatinverted index 1607B is a relevant index based on its location withinthe _main directory 1603 and the time range associated with it. For sakeof simplicity in this example, the search node 506 determines that noother inverted indexes in the _main directory 1603, such as invertedindex 1607A satisfy the time range criterion.

Having identified the relevant inverted index 1607B, the search node 506reviews the token entries 1611 and the field-value pair entries 1613 toidentify event references, or events that satisfy all of the filtercriteria.

With respect to the token entries 1611, the search node 506 can reviewthe error token entry and identify event references 3, 5, 6, 8, 11, 12,indicating that the term “error” is found in the corresponding events.Similarly, the search node 506 can identify event references 4, 5, 6, 8,9, 10, 11 in the field-value pair entry sourcetype::sourcetypeC andevent references 2, 5, 6, 8, 10, 11 in the field-value pair entryhost::hostB. As the filter criteria did not include a source or anIP_address field-value pair, the search node 506 can ignore thosefield-value pair entries.

In addition to identifying event references found in at least one tokenentry or field-value pair entry (e.g., event references 3, 4, 5, 6, 8,9, 10, 11, 12), the search node 506 can identify events (andcorresponding event references) that satisfy the time range criterionusing the event reference array 1615 (e.g., event references 2, 3, 4, 5,6, 7, 8, 9, 10). Using the information obtained from the inverted index1607B (including the event reference array 1615), the search node 506can identify the event references that satisfy all of the filtercriteria (e.g., event references 5, 6, 8).

Having identified the events (and event references) that satisfy all ofthe filter criteria, the search node 506 can group the event referencesusing the received categorization criteria (source). In doing so, thesearch node 506 can determine that event references 5 and 6 are locatedin the field-value pair entry source::sourceD (or have matchingcategorization criteria-value pairs) and event reference 8 is located inthe field-value pair entry source::sourceC. Accordingly, the search node506 can generate a sourceC group having a count of one corresponding toreference 8 and a sourceD group having a count of two corresponding toreferences 5 and 6. This information can be communicated to the searchhead 504. In turn the search head 504 can aggregate the results from thevarious search nodes 506 and display the groupings. As mentioned above,in some embodiments, the groupings can be displayed based at least inpart on the categorization criteria, including at least one of host,source, sourcetype, or partition.

It will be understood that a change to any of the filter criteria orcategorization criteria can result in different groupings. As a onenon-limiting example, consider a request received by a search node 506that includes the following filter criteria: partition=_main, timerange=3/1/17 3/1/17 16:21:20.000-16:28:17.000, and the followingcategorization criteria: host, source, sourcetype can result in thesearch node 506 identifying event references 1-12 as satisfying thefilter criteria. The search node 506 can generate up to 24 groupingscorresponding to the 24 different combinations of the categorizationcriteria-value pairs, including host (hostA, hostB), source (sourceA,sourceB, sourceC, sourceD), and sourcetype (sourcetypeA, sourcetypeB,sourcetypeC). However, as there are only twelve events identifiers inthe illustrated embodiment and some fall into the same grouping, thesearch node 506 generates eight groups and counts as follows:

-   -   Group 1 (hostA, sourceA, sourcetypeA): 1 (event reference 7)    -   Group 2 (hostA, sourceA, sourcetypeB): 2 (event references 1,        12)    -   Group 3 (hostA, sourceA, sourcetypeC): 1 (event reference 4)    -   Group 4 (hostA, sourceB, sourcetypeA): 1 (event reference 3)    -   Group 5 (hostA, sourceB, sourcetypeC): 1 (event reference 9)    -   Group 6 (hostB, sourceC, sourcetypeA): 1 (event reference 2)    -   Group 7 (hostB, sourceC, sourcetypeC): 2 (event references 8,        11)    -   Group 8 (hostB, sourceD, sourcetypeC): 3 (event references 5, 6,        10)

As noted, each group has a unique combination of categorizationcriteria-value pairs or categorization criteria values. The search node506 communicates the groups to the search head 504 for aggregation withresults received from other search nodes 506. In communicating thegroups to the search head 504, the search node 506 can include thecategorization criteria-value pairs for each group and the count. Insome embodiments, the search node 506 can include more or lessinformation. For example, the search node 506 can include the eventreferences associated with each group and other identifying information,such as the search node 506 or inverted index used to identify thegroups.

As another non-limiting example, consider a request received by ansearch node 506 that includes the following filter criteria:partition=_main, time range=3/1/17 3/1/17 16:21:20.000-16:28:17.000,source=sourceA, sourceD, and keyword=itemID and the followingcategorization criteria: host, source, sourcetype can result in thesearch node identifying event references 4, 7, and 10 as satisfying thefilter criteria, and generate the following groups:

-   -   Group 1 (hostA, sourceA, sourcetypeC): 1 (event reference 4)    -   Group 2 (hostA, sourceA, sourcetypeA): 1 (event reference 7)    -   Group 3 (hostB, sourceD, sourcetypeC): 1 (event references 10)

The search node 506 communicates the groups to the search head 504 foraggregation with results received from other search node 506 s. As willbe understand there are myriad ways for filtering and categorizing theevents and event references. For example, the search node 506 can reviewmultiple inverted indexes associated with a partition or review theinverted indexes of multiple partitions, and categorize the data usingany one or any combination of partition, host, source, sourcetype, orother category, as desired.

Further, if a user interacts with a particular group, the search node506 can provide additional information regarding the group. For example,the search node 506 can perform a targeted search or sampling of theevents that satisfy the filter criteria and the categorization criteriafor the selected group, also referred to as the filter criteriacorresponding to the group or filter criteria associated with the group.

In some cases, to provide the additional information, the search node506 relies on the inverted index. For example, the search node 506 canidentify the event references associated with the events that satisfythe filter criteria and the categorization criteria for the selectedgroup and then use the event reference array 1615 to access some or allof the identified events. In some cases, the categorization criteriavalues or categorization criteria-value pairs associated with the groupbecome part of the filter criteria for the review.

With reference to FIG. 16B for instance, suppose a group is displayedwith a count of six corresponding to event references 4, 5, 6, 8, 10, 11(i.e., event references 4, 5, 6, 8, 10, 11 satisfy the filter criteriaand are associated with matching categorization criteria values orcategorization criteria-value pairs) and a user interacts with the group(e.g., selecting the group, clicking on the group, etc.). In response,the search head 504 communicates with the search node 506 to provideadditional information regarding the group.

In some embodiments, the search node 506 identifies the event referencesassociated with the group using the filter criteria and thecategorization criteria for the group (e.g., categorization criteriavalues or categorization criteria-value pairs unique to the group).Together, the filter criteria and the categorization criteria for thegroup can be referred to as the filter criteria associated with thegroup. Using the filter criteria associated with the group, the searchnode 506 identifies event references 4, 5, 6, 8, 10, 11.

Based on a sampling criteria, discussed in greater detail above, thesearch node 506 can determine that it will analyze a sample of theevents associated with the event references 4, 5, 6, 8, 10, 11. Forexample, the sample can include analyzing event data associated with theevent references 5, 8, 10. In some embodiments, the search node 506 canuse the event reference array 1615 to access the event data associatedwith the event references 5, 8, 10. Once accessed, the search node 506can compile the relevant information and provide it to the search head504 for aggregation with results from other search nodes. By identifyingevents and sampling event data using the inverted indexes, the searchnode can reduce the amount of actual data this is analyzed and thenumber of events that are accessed in order to generate the summary ofthe group and provide a response in less time.

4.7. Query Processing Flow

FIG. 17A is a flow diagram illustrating an embodiment of a routineimplemented by the query system 214 for executing a query. At block1702, a search head 504 receives a search query. At block 1704, thesearch head 504 analyzes the search query to determine what portion(s)of the query to delegate to search nodes 506 and what portions of thequery to execute locally by the search head 504. At block 1706, thesearch head distributes the determined portions of the query to theappropriate search nodes 506. In some embodiments, a search head clustermay take the place of an independent search head 504 where each searchhead 504 in the search head cluster coordinates with peer search heads504 in the search head cluster to schedule jobs, replicate searchresults, update configurations, fulfill search requests, etc. In someembodiments, the search head 504 (or each search head) consults with aresource catalog 510 that provides the search head with a list of searchnodes 506 to which the search head can distribute the determinedportions of the query. A search head 504 may communicate with theresource catalog 510 to discover the addresses of active search nodes506.

At block 1708, the search nodes 506 to which the query was distributed,search data stores associated with them for events that are responsiveto the query. To determine which events are responsive to the query, thesearch node 506 searches for events that match the criteria specified inthe query. These criteria can include matching keywords or specificvalues for certain fields. The searching operations at block 1708 mayuse the late-binding schema to extract values for specified fields fromevents at the time the query is processed. In some embodiments, one ormore rules for extracting field values may be specified as part of asource type definition in a configuration file. The search nodes 506 maythen either send the relevant events back to the search head 504, or usethe events to determine a partial result, and send the partial resultback to the search head 504.

At block 1710, the search head 504 combines the partial results and/orevents received from the search nodes 506 to produce a final result forthe query. In some examples, the results of the query are indicative ofperformance or security of the IT environment and may help improve theperformance of components in the IT environment. This final result maycomprise different types of data depending on what the query requested.For example, the results can include a listing of matching eventsreturned by the query, or some type of visualization of the data fromthe returned events. In another example, the final result can includeone or more calculated values derived from the matching events.

The results generated by the system 108 can be returned to a clientusing different techniques. For example, one technique streams resultsor relevant events back to a client in real-time as they are identified.Another technique waits to report the results to the client until acomplete set of results (which may include a set of relevant events or aresult based on relevant events) is ready to return to the client. Yetanother technique streams interim results or relevant events back to theclient in real-time until a complete set of results is ready, and thenreturns the complete set of results to the client. In another technique,certain results are stored as “search jobs” and the client may retrievethe results by referring the search jobs.

The search head 504 can also perform various operations to make thesearch more efficient. For example, before the search head 504 beginsexecution of a query, the search head 504 can determine a time range forthe query and a set of common keywords that all matching events include.The search head 504 may then use these parameters to query the searchnodes 506 to obtain a superset of the eventual results. Then, during afiltering stage, the search head 504 can perform field-extractionoperations on the superset to produce a reduced set of search results.This speeds up queries, which may be particularly helpful for queriesthat are performed on a periodic basis.

4.8. Pipelined Search Language

Various embodiments of the present disclosure can be implemented using,or in conjunction with, a pipelined command language. A pipelinedcommand language is a language in which a set of inputs or data isoperated on by a first command in a sequence of commands, and thensubsequent commands in the order they are arranged in the sequence. Suchcommands can include any type of functionality for operating on data,such as retrieving, searching, filtering, aggregating, processing,transmitting, and the like. As described herein, a query can thus beformulated in a pipelined command language and include any number ofordered or unordered commands for operating on data.

Splunk Processing Language (SPL) is an example of a pipelined commandlanguage in which a set of inputs or data is operated on by any numberof commands in a particular sequence. A sequence of commands, or commandsequence, can be formulated such that the order in which the commandsare arranged defines the order in which the commands are applied to aset of data or the results of an earlier executed command. For example,a first command in a command sequence can operate to search or filterfor specific data in particular set of data. The results of the firstcommand can then be passed to another command listed later in thecommand sequence for further processing.

In various embodiments, a query can be formulated as a command sequencedefined in a command line of a search UI. In some embodiments, a querycan be formulated as a sequence of SPL commands. Some or all of the SPLcommands in the sequence of SPL commands can be separated from oneanother by a pipe symbol “I”. In such embodiments, a set of data, suchas a set of events, can be operated on by a first SPL command in thesequence, and then a subsequent SPL command following a pipe symbol “|”after the first SPL command operates on the results produced by thefirst SPL command or other set of data, and so on for any additional SPLcommands in the sequence. As such, a query formulated using SPLcomprises a series of consecutive commands that are delimited by pipe“|” characters. The pipe character indicates to the system that theoutput or result of one command (to the left of the pipe) should be usedas the input for one of the subsequent commands (to the right of thepipe). This enables formulation of queries defined by a pipeline ofsequenced commands that refines or enhances the data at each step alongthe pipeline until the desired results are attained. Accordingly,various embodiments described herein can be implemented with SplunkProcessing Language (SPL) used in conjunction with the SPLUNK®ENTERPRISE system.

While a query can be formulated in many ways, a query can start with asearch command and one or more corresponding search terms at thebeginning of the pipeline. Such search terms can include any combinationof keywords, phrases, times, dates, Boolean expressions, fieldname-fieldvalue pairs, etc. that specify which results should be obtained from anindex. The results can then be passed as inputs into subsequent commandsin a sequence of commands by using, for example, a pipe character. Thesubsequent commands in a sequence can include directives for additionalprocessing of the results once it has been obtained from one or moreindexes. For example, commands may be used to filter unwantedinformation out of the results, extract more information, evaluate fieldvalues, calculate statistics, reorder the results, create an alert,create summary of the results, or perform some type of aggregationfunction. In some embodiments, the summary can include a graph, chart,metric, or other visualization of the data. An aggregation function caninclude analysis or calculations to return an aggregate value, such asan average value, a sum, a maximum value, a root mean square,statistical values, and the like.

Due to its flexible nature, use of a pipelined command language invarious embodiments is advantageous because it can perform “filtering”as well as “processing” functions. In other words, a single query caninclude a search command and search term expressions, as well asdata-analysis expressions. For example, a command at the beginning of aquery can perform a “filtering” step by retrieving a set of data basedon a condition (e.g., records associated with server response times ofless than 1 microsecond). The results of the filtering step can then bepassed to a subsequent command in the pipeline that performs a“processing” step (e.g. calculation of an aggregate value related to thefiltered events such as the average response time of servers withresponse times of less than 1 microsecond). Furthermore, the searchcommand can allow events to be filtered by keyword as well as fieldvalue criteria. For example, a search command can filter out all eventscontaining the word “warning” or filter out all events where a fieldvalue associated with a field “clientip” is “10.0.1.2.”

The results obtained or generated in response to a command in a querycan be considered a set of results data. The set of results data can bepassed from one command to another in any data format. In oneembodiment, the set of result data can be in the form of a dynamicallycreated table. Each command in a particular query can redefine the shapeof the table. In some implementations, an event retrieved from an indexin response to a query can be considered a row with a column for eachfield value. Columns contain basic information about the data and alsomay contain data that has been dynamically extracted at search time.

FIG. 17B provides a visual representation of the manner in which apipelined command language or query operates in accordance with thedisclosed embodiments. The query 1730 can be inputted by the user into asearch. The query comprises a search, the results of which are piped totwo commands (namely, command 1 and command 2) that follow the searchstep.

Disk 1722 represents the event data in the raw record data store.

When a user query is processed, a search step will precede other queriesin the pipeline in order to generate a set of events at block 1740. Forexample, the query can comprise search terms “sourcetype=syslog ERROR”at the front of the pipeline as shown in FIG. 17B. Intermediate resultstable 1724 shows fewer rows because it represents the subset of eventsretrieved from the index that matched the search terms“sourcetype=syslog ERROR” from search command 1730. By way of furtherexample, instead of a search step, the set of events at the head of thepipeline may be generating by a call to a pre-existing inverted index(as will be explained later).

At block 1742, the set of events generated in the first part of thequery may be piped to a query that searches the set of events forfield-value pairs or for keywords. For example, the second intermediateresults table 1726 shows fewer columns, representing the result of thetop command, “top user” which summarizes the events into a list of thetop 10 users and displays the user, count, and percentage.

Finally, at block 1744, the results of the prior stage can be pipelinedto another stage where further filtering or processing of the data canbe performed, e.g., preparing the data for display purposes, filteringthe data based on a condition, performing a mathematical calculationwith the data, etc. As shown in FIG. 17B, the “fields—percent” part ofcommand 1730 removes the column that shows the percentage, thereby,leaving a final results table 1728 without a percentage column. Indifferent embodiments, other query languages, such as the StructuredQuery Language (“SQL”), can be used to create a query.

4.9. Field Extraction

The query system 214 allows users to search and visualize eventsgenerated from machine data received from heterogeneous data sources.The query system 214 also allows users to search and visualize eventsgenerated from machine data received from heterogeneous data sources.The query system 214 includes various components for processing a query,such as, but not limited to a query system manager 502, one or moresearch heads 504 having one or more search masters 512 and searchmanagers 514, and one or more search nodes 506. A query language may beused to create a query, such as any suitable pipelined query language.For example, Splunk Processing Language (SPL) can be utilized to make aquery. SPL is a pipelined search language in which a set of inputs isoperated on by a first command in a command line, and then a subsequentcommand following the pipe symbol “|” operates on the results producedby the first command, and so on for additional commands. Other querylanguages, such as the Structured Query Language (“SQL”), can be used tocreate a query.

In response to receiving the search query, a search head 504 (e.g., asearch master 512 or search manager 514) can use extraction rules toextract values for fields in the events being searched. The search head504 can obtain extraction rules that specify how to extract a value forfields from an event. Extraction rules can comprise regex rules thatspecify how to extract values for the fields corresponding to theextraction rules. In addition to specifying how to extract field values,the extraction rules may also include instructions for deriving a fieldvalue by performing a function on a character string or value retrievedby the extraction rule. For example, an extraction rule may truncate acharacter string or convert the character string into a different dataformat. In some cases, the query itself can specify one or moreextraction rules.

The search head 504 can apply the extraction rules to events that itreceives from search nodes 506. The search nodes 506 may apply theextraction rules to events in an associated data store or common storage216. Extraction rules can be applied to all the events in a data storeor common storage 216 or to a subset of the events that have beenfiltered based on some criteria (e.g., event time stamp values, etc.).Extraction rules can be used to extract one or more values for a fieldfrom events by parsing the portions of machine data in the events andexamining the data for one or more patterns of characters, numbers,delimiters, etc., that indicate where the field begins and, optionally,ends.

FIG. 18A is a diagram of an example scenario where a common customeridentifier is found among log data received from three disparate datasources, in accordance with example embodiments. In this example, a usersubmits an order for merchandise using a vendor's shopping applicationprogram 1801 running on the user's system. In this example, the orderwas not delivered to the vendor's server due to a resource exception atthe destination server that is detected by the middleware code 1802. Theuser then sends a message to the customer support server 1803 tocomplain about the order failing to complete. The three systems 1801,1802, and 1803 are disparate systems that do not have a common loggingformat. The order application 1801 sends log data 1804 to the dataintake and query system 108 in one format, the middleware code 1802sends error log data 1805 in a second format, and the support server1803 sends log data 1806 in a third format.

Using the log data received at the data intake and query system 108 fromthe three systems, the vendor can uniquely obtain an insight into useractivity, user experience, and system behavior. The query system 214allows the vendor's administrator to search the log data from the threesystems, thereby obtaining correlated information, such as the ordernumber and corresponding customer ID number of the person placing theorder. The system also allows the administrator to see a visualizationof related events via a user interface. The administrator can query thequery system 214 for customer ID field value matches across the log datafrom the three systems that are stored in common storage 216. Thecustomer ID field value exists in the data gathered from the threesystems, but the customer ID field value may be located in differentareas of the data given differences in the architecture of the systems.There is a semantic relationship between the customer ID field valuesgenerated by the three systems. The query system 214 requests eventsfrom the one or more data stores 218 to gather relevant events from thethree systems. The search head 504 then applies extraction rules to theevents in order to extract field values that it can correlate. Thesearch head 504 may apply a different extraction rule to each set ofevents from each system when the event format differs among systems. Inthis example, the user interface can display to the administrator theevents corresponding to the common customer ID field values 1807, 1808,and 1809, thereby providing the administrator with insight into acustomer's experience.

Note that query results can be returned to a client, a search head 504,or any other system component for further processing. In general, queryresults may include a set of one or more events, a set of one or morevalues obtained from the events, a subset of the values, statisticscalculated based on the values, a report containing the values, avisualization (e.g., a graph or chart) generated from the values, andthe like.

The query system 214 enables users to run queries against the storeddata to retrieve events that meet criteria specified in a query, such ascontaining certain keywords or having specific values in defined fields.FIG. 18B illustrates the manner in which keyword searches and fieldsearches are processed in accordance with disclosed embodiments.

If a user inputs a search query into search bar 1810 that includes onlykeywords (also known as “tokens”), e.g., the keyword “error” or“warning”, the query system 214 of the data intake and query system 108can search for those keywords directly in the event data 1811 stored inthe raw record data store. Note that while FIG. 18B only illustratesfour events 1812, 1813, 1814, 1815, the raw record data store(corresponding to data store 208 in FIG. 2) may contain records formillions of events.

As disclosed above, the indexing system 212 can optionally generate akeyword index to facilitate fast keyword searching for event data. Theindexing system 212 can include the identified keywords in an index,which associates each stored keyword with reference pointers to eventscontaining that keyword (or to locations within events where thatkeyword is located, other location identifiers, etc.). When the querysystem 214 subsequently receives a keyword-based query, the query system214 can access the keyword index to quickly identify events containingthe keyword. For example, if the keyword “HTTP” was indexed by theindexing system 212 at index time, and the user searches for the keyword“HTTP”, the events 1812, 1813, and 1814, will be identified based on theresults returned from the keyword index. As noted above, the indexcontains reference pointers to the events containing the keyword, whichallows for efficient retrieval of the relevant events from the rawrecord data store.

If a user searches for a keyword that has not been indexed by theindexing system 212, the data intake and query system 108 maynevertheless be able to retrieve the events by searching the event datafor the keyword in the raw record data store directly as shown in FIG.18B. For example, if a user searches for the keyword “frank”, and thename “frank” has not been indexed at search time, the query system 214can search the event data directly and return the first event 1812. Notethat whether the keyword has been indexed at index time or search timeor not, in both cases the raw data with the events 1811 is accessed fromthe raw data record store to service the keyword search. In the casewhere the keyword has been indexed, the index will contain a referencepointer that will allow for a more efficient retrieval of the event datafrom the data store. If the keyword has not been indexed, the querysystem 214 can search through the records in the data store to servicethe search.

In most cases, however, in addition to keywords, a user's search willalso include fields. The term “field” refers to a location in the eventdata containing one or more values for a specific data item. Often, afield is a value with a fixed, delimited position on a line, or a nameand value pair, where there is a single value to each field name. Afield can also be multivalued, that is, it can appear more than once inan event and have a different value for each appearance, e.g., emailaddress fields. Fields are searchable by the field name or fieldname-value pairs. Some examples of fields are “clientip” for IPaddresses accessing a web server, or the “From” and “To” fields in emailaddresses.

By way of further example, consider the search, “status=404”. Thissearch query finds events with “status” fields that have a value of“404.” When the search is run, the query system 214 does not look forevents with any other “status” value. It also does not look for eventscontaining other fields that share “404” as a value. As a result, thesearch returns a set of results that are more focused than if “404” hadbeen used in the search string as part of a keyword search. Note alsothat fields can appear in events as “key=value” pairs such as“user_name=Bob.” But in most cases, field values appear in fixed,delimited positions without identifying keys. For example, the datastore may contain events where the “user_name” value always appears byitself after the timestamp as illustrated by the following string: “Nov.15 09:33:22 evaemerson.”

The data intake and query system 108 advantageously allows for searchtime field extraction. In other words, fields can be extracted from theevent data at search time using late-binding schema as opposed to atdata ingestion time, which was a major limitation of the prior artsystems.

In response to receiving the search query, a search head 504 of thequery system 214 can use extraction rules to extract values for thefields associated with a field or fields in the event data beingsearched. The search head 504 can obtain extraction rules that specifyhow to extract a value for certain fields from an event. Extractionrules can comprise regex rules that specify how to extract values forthe relevant fields. In addition to specifying how to extract fieldvalues, the extraction rules may also include instructions for derivinga field value by performing a function on a character string or valueretrieved by the extraction rule. For example, a transformation rule maytruncate a character string, or convert the character string into adifferent data format. In some cases, the query itself can specify oneor more extraction rules.

FIG. 18B illustrates the manner in which configuration files may be usedto configure custom fields at search time in accordance with thedisclosed embodiments. In response to receiving a search query, the dataintake and query system 108 determines if the query references a“field.” For example, a query may request a list of events where the“clientip” field equals “127.0.0.1.” If the query itself does notspecify an extraction rule and if the field is not a metadata field,e.g., time, host, source, source type, etc., then in order to determinean extraction rule, the query system 214 may, in one or moreembodiments, need to locate configuration file 1816 during the executionof the search as shown in FIG. 18B.

Configuration file 1816 may contain extraction rules for all the variousfields that are not metadata fields, e.g., the “clientip” field. Theextraction rules may be inserted into the configuration file in avariety of ways. In some embodiments, the extraction rules can compriseregular expression rules that are manually entered in by the user.Regular expressions match patterns of characters in text and are usedfor extracting custom fields in text.

In one or more embodiments, as noted above, a field extractor may beconfigured to automatically generate extraction rules for certain fieldvalues in the events when the events are being created, indexed, orstored, or possibly at a later time. In one embodiment, a user may beable to dynamically create custom fields by highlighting portions of asample event that should be extracted as fields using a graphical userinterface. The system can then generate a regular expression thatextracts those fields from similar events and store the regularexpression as an extraction rule for the associated field in theconfiguration file 1816.

In some embodiments, the indexing system 212 can automatically discovercertain custom fields at index time and the regular expressions forthose fields will be automatically generated at index time and stored aspart of extraction rules in configuration file 1816. For example, fieldsthat appear in the event data as “key=value” pairs may be automaticallyextracted as part of an automatic field discovery process. Note thatthere may be several other ways of adding field definitions toconfiguration files in addition to the methods discussed herein.

The search head 504 can apply the extraction rules derived fromconfiguration file 1816 to event data that it receives from search nodes506. The search nodes 506 may apply the extraction rules from theconfiguration file to events in an associated data store or commonstorage 216. Extraction rules can be applied to all the events in a datastore, or to a subset of the events that have been filtered based onsome criteria (e.g., event time stamp values, etc.). Extraction rulescan be used to extract one or more values for a field from events byparsing the event data and examining the event data for one or morepatterns of characters, numbers, delimiters, etc., that indicate wherethe field begins and, optionally, ends.

In one more embodiments, the extraction rule in configuration file 1816will also need to define the type or set of events that the rule appliesto. Because the raw record data store will contain events from multipleheterogeneous sources, multiple events may contain the same fields indifferent locations because of discrepancies in the format of the datagenerated by the various sources. Furthermore, certain events may notcontain a particular field at all. For example, event 1815 also contains“clientip” field, however, the “clientip” field is in a different formatfrom events 1812, 1813, and 1814. To address the discrepancies in theformat and content of the different types of events, the configurationfile will also need to specify the set of events that an extraction ruleapplies to, e.g., extraction rule 1817 specifies a rule for filtering bythe type of event and contains a regular expression for parsing out thefield value. Accordingly, each extraction rule can pertain to only aparticular type of event. If a particular field, e.g., “clientip” occursin multiple types of events, each of those types of events can have itsown corresponding extraction rule in the configuration file 1816 andeach of the extraction rules would comprise a different regularexpression to parse out the associated field value. The most common wayto categorize events is by source type because events generated by aparticular source can have the same format.

The field extraction rules stored in configuration file 1816 performsearch-time field extractions. For example, for a query that requests alist of events with source type “access_combined” where the “clientip”field equals “127.0.0.1,” the query system 214 can first locate theconfiguration file 1816 to retrieve extraction rule 1817 that allows itto extract values associated with the “clientip” field from the eventdata 1820 “where the source type is “access_combined. After the“clientip” field has been extracted from all the events comprising the“clientip” field where the source type is “access_combined,” the querysystem 214 can then execute the field criteria by performing the compareoperation to filter out the events where the “clientip” field equals“127.0.0.1.” In the example shown in FIG. 18B, the events 1812, 1813,and 1814 would be returned in response to the user query. In thismanner, the query system 214 can service queries containing fieldcriteria in addition to queries containing keyword criteria (asexplained above).

In some embodiments, the configuration file 1816 can be created duringindexing. It may either be manually created by the user or automaticallygenerated with certain predetermined field extraction rules. Asdiscussed above, the events may be distributed across several datastores in common storage 216, wherein various indexing nodes 404 may beresponsible for storing the events in the common storage 216 and varioussearch nodes 506 may be responsible for searching the events containedin common storage 216.

The ability to add schema to the configuration file at search timeresults in increased efficiency. A user can create new fields at searchtime and simply add field definitions to the configuration file. As auser learns more about the data in the events, the user can continue torefine the late-binding schema by adding new fields, deleting fields, ormodifying the field extraction rules in the configuration file for usethe next time the schema is used by the system. Because the data intakeand query system 108 maintains the underlying raw data and useslate-binding schema for searching the raw data, it enables a user tocontinue investigating and learn valuable insights about the raw datalong after data ingestion time.

The ability to add multiple field definitions to the configuration fileat search time also results in increased flexibility. For example,multiple field definitions can be added to the configuration file tocapture the same field across events generated by different sourcetypes. This allows the data intake and query system 108 to search andcorrelate data across heterogeneous sources flexibly and efficiently.

Further, by providing the field definitions for the queried fields atsearch time, the configuration file 1816 allows the record data store tobe field searchable. In other words, the raw record data store can besearched using keywords as well as fields, wherein the fields aresearchable name/value pairings that distinguish one event from anotherand can be defined in configuration file 1816 using extraction rules. Incomparison to a search containing field names, a keyword search does notneed the configuration file and can search the event data directly asshown in FIG. 18B.

It should also be noted that any events filtered out by performing asearch-time field extraction using a configuration file 1816 can befurther processed by directing the results of the filtering step to aprocessing step using a pipelined search language. Using the priorexample, a user can pipeline the results of the compare step to anaggregate function by asking the query system 214 to count the number ofevents where the “clientip” field equals “127.0.0.1.”

4.10. Example Search Screen

FIG. 19A is an interface diagram of an example user interface for asearch screen 1900, in accordance with example embodiments. Searchscreen 1900 includes a search bar 1902 that accepts user input in theform of a search string. It also includes a time range picker 1912 thatenables the user to specify a time range for the search. For historicalsearches (e.g., searches based on a particular historical time range),the user can select a specific time range, or alternatively a relativetime range, such as “today,” “yesterday” or “last week.” For real-timesearches (e.g., searches whose results are based on data received inreal-time), the user can select the size of a preceding time window tosearch for real-time events. Search screen 1900 also initially displaysa “data summary” dialog as is illustrated in FIG. 19B that enables theuser to select different sources for the events, such as by selectingspecific hosts and log files.

After the search is executed, the search screen 1900 in FIG. 19A candisplay the results through search results tabs 1904, wherein searchresults tabs 1904 includes: an “events tab” that displays variousinformation about events returned by the search; a “statistics tab” thatdisplays statistics about the search results; and a “visualization tab”that displays various visualizations of the search results. The eventstab illustrated in FIG. 19A displays a timeline graph 1905 thatgraphically illustrates the number of events that occurred in one-hourintervals over the selected time range. The events tab also displays anevents list 1908 that enables a user to view the machine data in each ofthe returned events.

The events tab additionally displays a sidebar that is an interactivefield picker 1906. The field picker 1906 may be displayed to a user inresponse to the search being executed and allows the user to furtheranalyze the search results based on the fields in the events of thesearch results. The field picker 1906 includes field names thatreference fields present in the events in the search results. The fieldpicker may display any Selected Fields 1920 that a user has pre-selectedfor display (e.g., host, source, sourcetype) and may also display anyInteresting Fields 1922 that the system determines may be interesting tothe user based on pre-specified criteria (e.g., action, bytes,categoryid, clientip, date_hour, date_mday, date_minute, etc.). Thefield picker also provides an option to display field names for all thefields present in the events of the search results using the All Fieldscontrol 1924.

Each field name in the field picker 1906 has a value type identifier tothe left of the field name, such as value type identifier 1926. A valuetype identifier identifies the type of value for the respective field,such as an “a” for fields that include literal values or a “#” forfields that include numerical values.

Each field name in the field picker also has a unique value count to theright of the field name, such as unique value count 1928. The uniquevalue count indicates the number of unique values for the respectivefield in the events of the search results.

Each field name is selectable to view the events in the search resultsthat have the field referenced by that field name. For example, a usercan select the “host” field name, and the events shown in the eventslist 1908 will be updated with events in the search results that havethe field that is reference by the field name “host.”

4.11. Data Models

A data model is a hierarchically structured search-time mapping ofsemantic knowledge about one or more datasets. It encodes the domainknowledge used to build a variety of specialized searches of thosedatasets. Those searches, in turn, can be used to generate reports.

A data model is composed of one or more “objects” (or “data modelobjects”) that define or otherwise correspond to a specific set of data.An object is defined by constraints and attributes. An object'sconstraints are search criteria that define the set of events to beoperated on by running a search having that search criteria at the timethe data model is selected. An object's attributes are the set of fieldsto be exposed for operating on that set of events generated by thesearch criteria.

Objects in data models can be arranged hierarchically in parent/childrelationships. Each child object represents a subset of the datasetcovered by its parent object. The top-level objects in data models arecollectively referred to as “root objects.”

Child objects have inheritance. Child objects inherit constraints andattributes from their parent objects and may have additional constraintsand attributes of their own. Child objects provide a way of filteringevents from parent objects. Because a child object may provide anadditional constraint in addition to the constraints it has inheritedfrom its parent object, the dataset it represents may be a subset of thedataset that its parent represents. For example, a first data modelobject may define a broad set of data pertaining to e-mail activitygenerally, and another data model object may define specific datasetswithin the broad dataset, such as a subset of the e-mail data pertainingspecifically to e-mails sent. For example, a user can simply select an“e-mail activity” data model object to access a dataset relating toe-mails generally (e.g., sent or received), or select an “e-mails sent”data model object (or data sub-model object) to access a datasetrelating to e-mails sent.

Because a data model object is defined by its constraints (e.g., a setof search criteria) and attributes (e.g., a set of fields), a data modelobject can be used to quickly search data to identify a set of eventsand to identify a set of fields to be associated with the set of events.For example, an “e-mails sent” data model object may specify a searchfor events relating to e-mails that have been sent, and specify a set offields that are associated with the events. Thus, a user can retrieveand use the “e-mails sent” data model object to quickly search sourcedata for events relating to sent e-mails, and may be provided with alisting of the set of fields relevant to the events in a user interfacescreen.

Examples of data models can include electronic mail, authentication,databases, intrusion detection, malware, application state, alerts,compute inventory, network sessions, network traffic, performance,audits, updates, vulnerabilities, etc. Data models and their objects canbe designed by knowledge managers in an organization, and they canenable downstream users to quickly focus on a specific set of data. Auser iteratively applies a model development tool (not shown in FIG.19A) to prepare a query that defines a subset of events and assigns anobject name to that subset. A child subset is created by furtherlimiting a query that generated a parent subset.

Data definitions in associated schemas can be taken from the commoninformation model (CIM) or can be devised for a particular schema andoptionally added to the CIM. Child objects inherit fields from parentsand can include fields not present in parents. A model developer canselect fewer extraction rules than are available for the sourcesreturned by the query that defines events belonging to a model.Selecting a limited set of extraction rules can be a tool forsimplifying and focusing the data model, while allowing a userflexibility to explore the data subset. Development of a data model isfurther explained in U.S. Pat. Nos. 8,788,525 and 8,788,526, bothentitled “DATA MODEL FOR MACHINE DATA FOR SEMANTIC SEARCH”, both issuedon 22 Jul. 2014, U.S. Pat. No. 8,983,994, entitled “GENERATION OF A DATAMODEL FOR SEARCHING MACHINE DATA”, issued on 17 Mar. 2015, U.S. Pat. No.9,128,980, entitled “GENERATION OF A DATA MODEL APPLIED TO QUERIES”,issued on 8 Sep. 2015, and U.S. Pat. No. 9,589,012, entitled “GENERATIONOF A DATA MODEL APPLIED TO OBJECT QUERIES”, issued on 7 Mar. 2017, eachof which is hereby incorporated by reference in its entirety for allpurposes.

A data model can also include reports. One or more report formats can beassociated with a particular data model and be made available to runagainst the data model. A user can use child objects to design reportswith object datasets that already have extraneous data pre-filtered out.In some embodiments, the data intake and query system 108 provides theuser with the ability to produce reports (e.g., a table, chart,visualization, etc.) without having to enter SPL, SQL, or other querylanguage terms into a search screen. Data models are used as the basisfor the search feature.

Data models may be selected in a report generation interface. The reportgenerator supports drag-and-drop organization of fields to be summarizedin a report. When a model is selected, the fields with availableextraction rules are made available for use in the report. The user mayrefine and/or filter search results to produce more precise reports. Theuser may select some fields for organizing the report and select otherfields for providing detail according to the report organization. Forexample, “region” and “salesperson” are fields used for organizing thereport and sales data can be summarized (subtotaled and totaled) withinthis organization. The report generator allows the user to specify oneor more fields within events and apply statistical analysis on valuesextracted from the specified one or more fields. The report generatormay aggregate search results across sets of events and generatestatistics based on aggregated search results. Building reports usingthe report generation interface is further explained in U.S. patentapplication Ser. No. 14/503,335, entitled “GENERATING REPORTS FROMUNSTRUCTURED DATA”, filed on 30 Sep. 2014, and which is herebyincorporated by reference in its entirety for all purposes. Datavisualizations also can be generated in a variety of formats, byreference to the data model. Reports, data visualizations, and datamodel objects can be saved and associated with the data model for futureuse. The data model object may be used to perform searches of otherdata.

FIGS. 20-26 are interface diagrams of example report generation userinterfaces, in accordance with example embodiments. The reportgeneration process may be driven by a predefined data model object, suchas a data model object defined and/or saved via a reporting applicationor a data model object obtained from another source. A user can load asaved data model object using a report editor. For example, the initialsearch query and fields used to drive the report editor may be obtainedfrom a data model object. The data model object that is used to drive areport generation process may define a search and a set of fields. Uponloading of the data model object, the report generation process mayenable a user to use the fields (e.g., the fields defined by the datamodel object) to define criteria for a report (e.g., filters, splitrows/columns, aggregates, etc.) and the search may be used to identifyevents (e.g., to identify events responsive to the search) used togenerate the report. That is, for example, if a data model object isselected to drive a report editor, the graphical user interface of thereport editor may enable a user to define reporting criteria for thereport using the fields associated with the selected data model object,and the events used to generate the report may be constrained to theevents that match, or otherwise satisfy, the search constraints of theselected data model object.

The selection of a data model object for use in driving a reportgeneration may be facilitated by a data model object selectioninterface. FIG. 20 illustrates an example interactive data modelselection graphical user interface 2000 of a report editor that displaysa listing of available data models 2001. The user may select one of thedata models 2002.

FIG. 21 illustrates an example data model object selection graphicaluser interface 2100 that displays available data objects 2101 for theselected data object model 2002. The user may select one of thedisplayed data model objects 2102 for use in driving the reportgeneration process.

Once a data model object is selected by the user, a user interfacescreen 2200 shown in FIG. 22A may display an interactive listing ofautomatic field identification options 2201 based on the selected datamodel object. For example, a user may select one of the threeillustrated options (e.g., the “All Fields” option 2202, the “SelectedFields” option 2203, or the “Coverage” option (e.g., fields with atleast a specified % of coverage) 2204). If the user selects the “AllFields” option 2202, all of the fields identified from the events thatwere returned in response to an initial search query may be selected.That is, for example, all of the fields of the identified data modelobject fields may be selected. If the user selects the “Selected Fields”option 2203, only the fields from the fields of the identified datamodel object fields that are selected by the user may be used. If theuser selects the “Coverage” option 2204, only the fields of theidentified data model object fields meeting a specified coveragecriteria may be selected. A percent coverage may refer to the percentageof events returned by the initial search query that a given fieldappears in. Thus, for example, if an object dataset includes 10,000events returned in response to an initial search query, and the“avg_age” field appears in 854 of those 10,000 events, then the“avg_age” field would have a coverage of 8.54% for that object dataset.If, for example, the user selects the “Coverage” option and specifies acoverage value of 2%, only fields having a coverage value equal to orgreater than 2% may be selected. The number of fields corresponding toeach selectable option may be displayed in association with each option.For example, “97” displayed next to the “All Fields” option 2202indicates that 97 fields will be selected if the “All Fields” option isselected. The “3” displayed next to the “Selected Fields” option 2203indicates that 3 of the 97 fields will be selected if the “SelectedFields” option is selected. The “49” displayed next to the “Coverage”option 2204 indicates that 49 of the 97 fields (e.g., the 49 fieldshaving a coverage of 2% or greater) will be selected if the “Coverage”option is selected. The number of fields corresponding to the “Coverage”option may be dynamically updated based on the specified percent ofcoverage.

FIG. 22B illustrates an example graphical user interface screen 2205displaying the reporting application's “Report Editor” page. The screenmay display interactive elements for defining various elements of areport. For example, the page includes a “Filters” element 2206, a“Split Rows” element 2207, a “Split Columns” element 2208, and a “ColumnValues” element 2209. The page may include a list of search results2211. In this example, the Split Rows element 2207 is expanded,revealing a listing of fields 2210 that can be used to define additionalcriteria (e.g., reporting criteria). The listing of fields 2210 maycorrespond to the selected fields. That is, the listing of fields 2210may list only the fields previously selected, either automaticallyand/or manually by a user. FIG. 22C illustrates a formatting dialogue2212 that may be displayed upon selecting a field from the listing offields 2210. The dialogue can be used to format the display of theresults of the selection (e.g., label the column for the selected fieldto be displayed as “component”).

FIG. 22D illustrates an example graphical user interface screen 2205including a table of results 2213 based on the selected criteriaincluding splitting the rows by the “component” field. A column 2214having an associated count for each component listed in the table may bedisplayed that indicates an aggregate count of the number of times thatthe particular field-value pair (e.g., the value in a row for aparticular field, such as the value “BucketMover” for the field“component”) occurs in the set of events responsive to the initialsearch query.

FIG. 23 illustrates an example graphical user interface screen 2300 thatallows the user to filter search results and to perform statisticalanalysis on values extracted from specific fields in the set of events.In this example, the top ten product names ranked by price are selectedas a filter 2301 that causes the display of the ten most popularproducts sorted by price. Each row is displayed by product name andprice 2302. This results in each product displayed in a column labeled“product name” along with an associated price in a column labeled“price” 2306. Statistical analysis of other fields in the eventsassociated with the ten most popular products have been specified ascolumn values 2303. A count of the number of successful purchases foreach product is displayed in column 2304. These statistics may beproduced by filtering the search results by the product name, findingall occurrences of a successful purchase in a field within the eventsand generating a total of the number of occurrences. A sum of the totalsales is displayed in column 2305, which is a result of themultiplication of the price and the number of successful purchases foreach product.

The reporting application allows the user to create graphicalvisualizations of the statistics generated for a report. For example,FIG. 24 illustrates an example graphical user interface 2400 thatdisplays a set of components and associated statistics 2401. Thereporting application allows the user to select a visualization of thestatistics in a graph (e.g., bar chart, scatter plot, area chart, linechart, pie chart, radial gauge, marker gauge, filler gauge, etc.), wherethe format of the graph may be selected using the user interfacecontrols 2402 along the left panel of the user interface 2400. FIG. 25illustrates an example of a bar chart visualization 2500 of an aspect ofthe statistical data 2401. FIG. 26 illustrates a scatter plotvisualization 2600 of an aspect of the statistical data 2401.

4.12. Acceleration Techniques

The above-described system provides significant flexibility by enablinga user to analyze massive quantities of minimally-processed data “on thefly” at search time using a late-binding schema, instead of storingpre-specified portions of the data in a database at ingestion time. Thisflexibility enables a user to see valuable insights, correlate data, andperform subsequent queries to examine interesting aspects of the datathat may not have been apparent at ingestion time.

However, performing extraction and analysis operations at search timecan involve a large amount of data and require a large number ofcomputational operations, which can cause delays in processing thequeries. Advantageously, the data intake and query system 108 alsoemploys a number of unique acceleration techniques that have beendeveloped to speed up analysis operations performed at search time.These techniques include: (1) performing search operations in parallelusing multiple search nodes 506; (2) using a keyword index; (3) using ahigh performance analytics store; and (4) accelerating the process ofgenerating reports. These novel techniques are described in more detailbelow.

4.12.1. Aggregation Technique

To facilitate faster query processing, a query can be structured suchthat multiple search nodes 506 perform the query in parallel, whileaggregation of search results from the multiple search nodes 506 isperformed at the search head 504. For example, FIG. 27 is an examplesearch query received from a client and executed by search nodes 506, inaccordance with example embodiments. FIG. 27 illustrates how a searchquery 2702 received from a client at a search head 504 can split intotwo phases, including: (1) subtasks 2704 (e.g., data retrieval or simplefiltering) that may be performed in parallel by search nodes 506 forexecution, and (2) a search results aggregation operation 2706 to beexecuted by the search head 504 when the results are ultimatelycollected from the search nodes 506.

During operation, upon receiving search query 2702, a search head 504determines that a portion of the operations involved with the searchquery may be performed locally by the search head 504. The search head504 modifies search query 2702 by substituting “stats” (create aggregatestatistics over results sets received from the search nodes 506 at thesearch head 504) with “prestats” (create statistics by the search node506 from local results set) to produce search query 2704, and thendistributes search query 2704 to distributed search nodes 506, which arealso referred to as “search peers” or “peer search nodes.” Note thatsearch queries may generally specify search criteria or operations to beperformed on events that meet the search criteria. Search queries mayalso specify field names, as well as search criteria for the values inthe fields or operations to be performed on the values in the fields.Moreover, the search head 504 may distribute the full search query tothe search peers, or may alternatively distribute a modified version(e.g., a more restricted version) of the search query to the searchpeers. In this example, the search nodes 506 are responsible forproducing the results and sending them to the search head 504. After thesearch nodes 506 return the results to the search head 504, the searchhead 504 aggregates the received results 2706 to form a single searchresult set. By executing the query in this manner, the systemeffectively distributes the computational operations across the searchnodes 506 while minimizing data transfers.

4.12.2. Keyword Index

As described herein, the data intake and query system 108 can constructand maintain one or more keyword indexes to quickly identify eventscontaining specific keywords. This technique can greatly speed up theprocessing of queries involving specific keywords. As mentioned above,to build a keyword index, an indexing node 404 first identifies a set ofkeywords. Then, the indexing node 404 includes the identified keywordsin an index, which associates each stored keyword with references toevents containing that keyword, or to locations within events where thatkeyword is located. When the query system 214 subsequently receives akeyword-based query, the indexer can access the keyword index to quicklyidentify events containing the keyword.

4.12.3. High Performance Analytics Store

To speed up certain types of queries, some embodiments of data intakeand query system 108 create a high performance analytics store, which isreferred to as a “summarization table,” that contains entries forspecific field-value pairs. Each of these entries keeps track ofinstances of a specific value in a specific field in the events andincludes references to events containing the specific value in thespecific field. For example, an example entry in a summarization tablecan keep track of occurrences of the value “94107” in a “ZIP code” fieldof a set of events and the entry includes references to all of theevents that contain the value “94107” in the ZIP code field. Thisoptimization technique enables the system to quickly process queriesthat seek to determine how many events have a particular value for aparticular field. To this end, the system can examine the entry in thesummarization table to count instances of the specific value in thefield without having to go through the individual events or perform dataextractions at search time. Also, if the system needs to process allevents that have a specific field-value combination, the system can usethe references in the summarization table entry to directly access theevents to extract further information without having to search all ofthe events to find the specific field-value combination at search time.

In some embodiments, the system maintains a separate summarization tablefor each of the above-described time-specific buckets that stores eventsfor a specific time range. A bucket-specific summarization tableincludes entries for specific field-value combinations that occur inevents in the specific bucket. Alternatively, the system can maintain asummarization table for the common storage 216, one or more data stores218 of the common storage 216, buckets cached on a search node 506, etc.The different summarization tables can include entries for the events inthe common storage 216, certain data stores 218 in the common storage216, or data stores associated with a particular search node 506, etc.

The summarization table can be populated by running a periodic querythat scans a set of events to find instances of a specific field-valuecombination, or alternatively instances of all field-value combinationsfor a specific field. A periodic query can be initiated by a user, orcan be scheduled to occur automatically at specific time intervals. Aperiodic query can also be automatically launched in response to a querythat asks for a specific field-value combination.

In some cases, when the summarization tables may not cover all of theevents that are relevant to a query, the system can use thesummarization tables to obtain partial results for the events that arecovered by summarization tables, but may also have to search throughother events that are not covered by the summarization tables to produceadditional results. These additional results can then be combined withthe partial results to produce a final set of results for the query. Thesummarization table and associated techniques are described in moredetail in U.S. Pat. No. 8,682,925, entitled “DISTRIBUTED HIGHPERFORMANCE ANALYTICS STORE”, issued on 25 Mar. 2014, U.S. Pat. No.9,128,985, entitled “SUPPLEMENTING A HIGH PERFORMANCE ANALYTICS STOREWITH EVALUATION OF INDIVIDUAL EVENTS TO RESPOND TO AN EVENT QUERY”,issued on 8 Sep. 2015, and U.S. patent application Ser. No. 14/815,973,entitled “GENERATING AND STORING SUMMARIZATION TABLES FOR SETS OFSEARCHABLE EVENTS”, filed on 1 Aug. 2015, each of which is herebyincorporated by reference in its entirety for all purposes.

To speed up certain types of queries, e.g., frequently encounteredqueries or computationally intensive queries, some embodiments of dataintake and query system 108 create a high performance analytics store,which is referred to as a “summarization table,” (also referred to as a“lexicon” or “inverted index”) that contains entries for specificfield-value pairs. Each of these entries keeps track of instances of aspecific value in a specific field in the event data and includesreferences to events containing the specific value in the specificfield. For example, an example entry in an inverted index can keep trackof occurrences of the value “94107” in a “ZIP code” field of a set ofevents and the entry includes references to all of the events thatcontain the value “94107” in the ZIP code field. Creating the invertedindex data structure avoids needing to incur the computational overheadeach time a statistical query needs to be run on a frequentlyencountered field-value pair. In order to expedite queries, in certainembodiments, the query system 214 can employ the inverted index separatefrom the raw record data store to generate responses to the receivedqueries.

Note that the term “summarization table” or “inverted index” as usedherein is a data structure that may be generated by the indexing system212 that includes at least field names and field values that have beenextracted and/or indexed from event records. An inverted index may alsoinclude reference values that point to the location(s) in the fieldsearchable data store where the event records that include the field maybe found. Also, an inverted index may be stored using variouscompression techniques to reduce its storage size.

Further, note that the term “reference value” (also referred to as a“posting value”) as used herein is a value that references the locationof a source record in the field searchable data store. In someembodiments, the reference value may include additional informationabout each record, such as timestamps, record size, meta-data, or thelike. Each reference value may be a unique identifier which may be usedto access the event data directly in the field searchable data store. Insome embodiments, the reference values may be ordered based on eachevent record's timestamp. For example, if numbers are used asidentifiers, they may be sorted so event records having a latertimestamp always have a lower valued identifier than event records withan earlier timestamp, or vice-versa. Reference values are often includedin inverted indexes for retrieving and/or identifying event records.

In one or more embodiments, an inverted index is generated in responseto a user-initiated collection query. The term “collection query” asused herein refers to queries that include commands that generatesummarization information and inverted indexes (or summarization tables)from event records stored in the field searchable data store.

Note that a collection query is a special type of query that can beuser-generated and is used to create an inverted index. A collectionquery is not the same as a query that is used to call up or invoke apre-existing inverted index. In one or more embodiments, a query cancomprise an initial step that calls up a pre-generated inverted index onwhich further filtering and processing can be performed. For example,referring back to FIG. 17B, a set of events can be generated at block1740 by either using a “collection” query to create a new inverted indexor by calling up a pre-generated inverted index. A query with severalpipelined steps will start with a pre-generated index to accelerate thequery.

FIG. 18C illustrates the manner in which an inverted index is createdand used in accordance with the disclosed embodiments. As shown in FIG.18C, an inverted index 1822 can be created in response to auser-initiated collection query using the event data 1823 stored in theraw record data store. For example, a non-limiting example of acollection query may include “collect clientip=127.0.0.1” which mayresult in an inverted index 1822 being generated from the event data1823 as shown in FIG. 18C. Each entry in inverted index 1822 includes anevent reference value that references the location of a source record inthe field searchable data store. The reference value may be used toaccess the original event record directly from the field searchable datastore.

In one or more embodiments, if one or more of the queries is acollection query, the one or more search nodes 506 may generatesummarization information based on the fields of the event recordslocated in the field searchable data store. In at least one of thevarious embodiments, one or more of the fields used in the summarizationinformation may be listed in the collection query and/or they may bedetermined based on terms included in the collection query. For example,a collection query may include an explicit list of fields to summarize.Or, in at least one of the various embodiments, a collection query mayinclude terms or expressions that explicitly define the fields, e.g.,using regex rules. In FIG. 18C, prior to running the collection querythat generates the inverted index 1822, the field name “clientip” mayneed to be defined in a configuration file by specifying the“access_combined” source type and a regular expression rule to parse outthe client IP address. Alternatively, the collection query may containan explicit definition for the field name “clientip” which may obviatethe need to reference the configuration file at search time.

In one or more embodiments, collection queries may be saved andscheduled to run periodically. These scheduled collection queries mayperiodically update the summarization information corresponding to thequery. For example, if the collection query that generates invertedindex 1822 is scheduled to run periodically, one or more search nodes506 can periodically search through the relevant buckets to updateinverted index 1822 with event data for any new events with the“clientip” value of “127.0.0.1.”

In some embodiments, the inverted indexes that include fields, values,and reference value (e.g., inverted index 1822) for event records may beincluded in the summarization information provided to the user. In otherembodiments, a user may not be interested in specific fields and valuescontained in the inverted index, but may need to perform a statisticalquery on the data in the inverted index. For example, referencing theexample of FIG. 18C rather than viewing the fields within the invertedindex 1822, a user may want to generate a count of all client requestsfrom IP address “127.0.0.1.” In this case, the query system 214 cansimply return a result of “4” rather than including details about theinverted index 1822 in the information provided to the user.

The pipelined search language, e.g., SPL of the SPLUNK® ENTERPRISEsystem can be used to pipe the contents of an inverted index to astatistical query using the “stats” command for example. A “stats” queryrefers to queries that generate result sets that may produce aggregateand statistical results from event records, e.g., average, mean, max,min, rms, etc. Where sufficient information is available in an invertedindex, a “stats” query may generate their result sets rapidly from thesummarization information available in the inverted index rather thandirectly scanning event records. For example, the contents of invertedindex 1822 can be pipelined to a stats query, e.g., a “count” functionthat counts the number of entries in the inverted index and returns avalue of “4.” In this way, inverted indexes may enable various statsqueries to be performed absent scanning or search the event records.Accordingly, this optimization technique enables the system to quicklyprocess queries that seek to determine how many events have a particularvalue for a particular field. To this end, the system can examine theentry in the inverted index to count instances of the specific value inthe field without having to go through the individual events or performdata extractions at search time.

In some embodiments, the system maintains a separate inverted index foreach of the above-described time-specific buckets that stores events fora specific time range. A bucket-specific inverted index includes entriesfor specific field-value combinations that occur in events in thespecific bucket. Alternatively, the system can maintain a separateinverted index for one or more data stores 218 of common storage 216, anindexing node 404, or a search node 506. The specific inverted indexescan include entries for the events in the one or more data stores 218 ordata store associated with the indexing nodes 404 or search node 506. Insome embodiments, if one or more of the queries is a stats query, asearch node 506 can generate a partial result set from previouslygenerated summarization information. The partial result sets may bereturned to the search head 504 that received the query and combinedinto a single result set for the query

As mentioned above, the inverted index can be populated by running aperiodic query that scans a set of events to find instances of aspecific field-value combination, or alternatively instances of allfield-value combinations for a specific field. A periodic query can beinitiated by a user, or can be scheduled to occur automatically atspecific time intervals. A periodic query can also be automaticallylaunched in response to a query that asks for a specific field-valuecombination. In some embodiments, if summarization information is absentfrom a search node 506 that includes responsive event records, furtheractions may be taken, such as, the summarization information maygenerated on the fly, warnings may be provided the user, the collectionquery operation may be halted, the absence of summarization informationmay be ignored, or the like, or combination thereof.

In one or more embodiments, an inverted index may be set up to updatecontinually. For example, the query may ask for the inverted index toupdate its result periodically, e.g., every hour. In such instances, theinverted index may be a dynamic data structure that is regularly updatedto include information regarding incoming events.

4.12.3.1. Extracting Event Data Using Posting

In one or more embodiments, if the system needs to process all eventsthat have a specific field-value combination, the system can use thereferences in the inverted index entry to directly access the events toextract further information without having to search all of the eventsto find the specific field-value combination at search time. In otherwords, the system can use the reference values to locate the associatedevent data in the field searchable data store and extract furtherinformation from those events, e.g., extract further field values fromthe events for purposes of filtering or processing or both.

The information extracted from the event data using the reference valuescan be directed for further filtering or processing in a query using thepipeline search language. The pipelined search language will, in oneembodiment, include syntax that can direct the initial filtering step ina query to an inverted index. In one embodiment, a user would includesyntax in the query that explicitly directs the initial searching orfiltering step to the inverted index.

Referencing the example in FIG. 16C, if the user determines that sheneeds the user id fields associated with the client requests from IPaddress “127.0.0.1,” instead of incurring the computational overhead ofperforming a brand new search or re-generating the inverted index withan additional field, the user can generate a query that explicitlydirects or pipes the contents of the already generated inverted index1822 to another filtering step requesting the user ids for the entriesin inverted index 1822 where the server response time is greater than“0.0900” microseconds. The query system 214 can use the reference valuesstored in inverted index 1822 to retrieve the event data from the fieldsearchable data store, filter the results based on the “response time”field values and, further, extract the user id field from the resultingevent data to return to the user. In the present instance, the user ids“frank” and “carlos” would be returned to the user from the generatedresults table 1825.

In one embodiment, the same methodology can be used to pipe the contentsof the inverted index to a processing step. In other words, the user isable to use the inverted index to efficiently and quickly performaggregate functions on field values that were not part of the initiallygenerated inverted index. For example, a user may want to determine anaverage object size (size of the requested gif) requested by clientsfrom IP address “127.0.0.1.” In this case, the query system 214 canagain use the reference values stored in inverted index 1822 to retrievethe event data from the field searchable data store and, further,extract the object size field values from the associated events 1831,1832, 1833 and 1834. Once, the corresponding object sizes have beenextracted (i.e. 2326, 2900, 2920, and 5000), the average can be computedand returned to the user.

In one embodiment, instead of explicitly invoking the inverted index ina user-generated query, e.g., by the use of special commands or syntax,the SPLUNK® ENTERPRISE system can be configured to automaticallydetermine if any prior-generated inverted index can be used to expeditea user query. For example, the user's query may request the averageobject size (size of the requested gif) requested by clients from IPaddress “127.0.0.1.” without any reference to or use of inverted index1822. The query system 214, in this case, can automatically determinethat an inverted index 1822 already exists in the system that couldexpedite this query. In one embodiment, prior to running any searchcomprising a field-value pair, for example, a query system 214 cansearch though all the existing inverted indexes to determine if apre-generated inverted index could be used to expedite the searchcomprising the field-value pair. Accordingly, the query system 214 canautomatically use the pre-generated inverted index, e.g., index 1822 togenerate the results without any user-involvement that directs the useof the index.

Using the reference values in an inverted index to be able to directlyaccess the event data in the field searchable data store and extractfurther information from the associated event data for further filteringand processing is highly advantageous because it avoids incurring thecomputation overhead of regenerating the inverted index with additionalfields or performing a new search.

The data intake and query system 108 includes an intake system 210 thatreceives data from a variety of input data sources, and an indexingsystem 212 that processes and stores the data in one or more data storesor common storage 216. By distributing events among the data stores 218of common storage 213, the query system 214 can analyze events for aquery in parallel. In some embodiments, the data intake and query system108 can maintain a separate and respective inverted index for each ofthe above-described time-specific buckets that stores events for aspecific time range. A bucket-specific inverted index includes entriesfor specific field-value combinations that occur in events in thespecific bucket. As explained above, a search head 504 can correlate andsynthesize data from across the various buckets and search nodes 506.

This feature advantageously expedites searches because instead ofperforming a computationally intensive search in a centrally locatedinverted index that catalogues all the relevant events, a search node506 is able to directly search an inverted index stored in a bucketassociated with the time-range specified in the query. This allows thesearch to be performed in parallel across the various search nodes 506.Further, if the query requests further filtering or processing to beconducted on the event data referenced by the locally storedbucket-specific inverted index, the search node 506 is able to simplyaccess the event records stored in the associated bucket for furtherfiltering and processing instead of needing to access a centralrepository of event records, which would dramatically add to thecomputational overhead.

In one embodiment, there may be multiple buckets associated with thetime-range specified in a query. If the query is directed to an invertedindex, or if the query system 214 automatically determines that using aninverted index can expedite the processing of the query, the searchnodes 506 can search through each of the inverted indexes associatedwith the buckets for the specified time-range. This feature allows theHigh Performance Analytics Store to be scaled easily.

FIG. 18D is a flow diagram illustrating an embodiment of a routineimplemented by one or more computing devices of the data intake andquery system for using an inverted index in a pipelined search query todetermine a set of event data that can be further limited by filteringor processing. For example, the routine can be implemented by any one orany combination of the search head 504, search node 506, search master512, or search manager 514, etc. However, for simplicity, referencebelow is made to the query system 214 performing the various steps ofthe routine.

At block 1842, a query is received by a data intake and query system108. In some embodiments, the query can be received as a user generatedquery entered into search bar of a graphical user search interface. Thesearch interface also includes a time range control element that enablesspecification of a time range for the query.

At block 1844, an inverted index is retrieved. Note, that the invertedindex can be retrieved in response to an explicit user search commandinputted as part of the user generated query. Alternatively, a querysystem 214 can be configured to automatically use an inverted index ifit determines that using the inverted index would expedite the servicingof the user generated query. Each of the entries in an inverted indexkeeps track of instances of a specific value in a specific field in theevent data and includes references to events containing the specificvalue in the specific field. In order to expedite queries, in someembodiments, the query system 214 employs the inverted index separatefrom the raw record data store to generate responses to the receivedqueries.

At block 1846, the query system 214 determines if the query containsfurther filtering and processing steps. If the query contains no furthercommands, then, in one embodiment, summarization information can beprovided to the user at block 1854.

If, however, the query does contain further filtering and processingcommands, then at block 1848, the query system 214 determines if thecommands relate to further filtering or processing of the data extractedas part of the inverted index or whether the commands are directed tousing the inverted index as an initial filtering step to further filterand process event data referenced by the entries in the inverted index.If the query can be completed using data already in the generatedinverted index, then the further filtering or processing steps, e.g., a“count” number of records function, “average” number of records per houretc. are performed and the results are provided to the user at block1850.

If, however, the query references fields that are not extracted in theinverted index, the query system 214 can access event data pointed to bythe reference values in the inverted index to retrieve any furtherinformation required at block 1856. Subsequently, any further filteringor processing steps are performed on the fields extracted directly fromthe event data and the results are provided to the user at step 1858.

4.12.4. Accelerating Report Generation

In some embodiments, a data server system such as the data intake andquery system 108 can accelerate the process of periodically generatingupdated reports based on query results. To accelerate this process, asummarization engine can automatically examine the query to determinewhether generation of updated reports can be accelerated by creatingintermediate summaries. If reports can be accelerated, the summarizationengine periodically generates a summary covering data obtained during alatest non-overlapping time period. For example, where the query seeksevents meeting a specified criteria, a summary for the time period mayonly include events within the time period that meet the specifiedcriteria. Similarly, if the query seeks statistics calculated from theevents, such as the number of events that match the specified criteria,then the summary for the time period includes the number of events inthe period that match the specified criteria.

In addition to the creation of the summaries, the summarization engineschedules the periodic updating of the report associated with the query.During each scheduled report update, the query system 214 determineswhether intermediate summaries have been generated covering portions ofthe time period covered by the report update. If so, then the report isgenerated based on the information contained in the summaries. Also, ifadditional event data has been received and has not yet been summarized,and is required to generate the complete report, the query can be run onthese additional events. Then, the results returned by this query on theadditional events, along with the partial results obtained from theintermediate summaries, can be combined to generate the updated report.This process is repeated each time the report is updated. Alternatively,if the system stores events in buckets covering specific time ranges,then the summaries can be generated on a bucket-by-bucket basis. Notethat producing intermediate summaries can save the work involved inre-running the query for previous time periods, so advantageously onlythe newer events needs to be processed while generating an updatedreport. These report acceleration techniques are described in moredetail in U.S. Pat. No. 8,589,403, entitled “COMPRESSED JOURNALING INEVENT TRACKING FILES FOR METADATA RECOVERY AND REPLICATION”, issued on19 Nov. 2013, U.S. Pat. No. 8,412,696, entitled “REAL TIME SEARCHING ANDREPORTING”, issued on 2 Apr. 2011, and U.S. Pat. Nos. 8,589,375 and8,589,432, both also entitled “REAL TIME SEARCHING AND REPORTING”, bothissued on 19 Nov. 2013, each of which is hereby incorporated byreference in its entirety for all purposes.

4.13. Security Features

The data intake and query system 108 provides various schemas,dashboards, and visualizations that simplify developers' tasks to createapplications with additional capabilities. One such application is thean enterprise security application, such as SPLUNK® ENTERPRISE SECURITY,which performs monitoring and alerting operations and includes analyticsto facilitate identifying both known and unknown security threats basedon large volumes of data stored by the data intake and query system 108.The enterprise security application provides the security practitionerwith visibility into security-relevant threats found in the enterpriseinfrastructure by capturing, monitoring, and reporting on data fromenterprise security devices, systems, and applications. Through the useof the data intake and query system 108 searching and reportingcapabilities, the enterprise security application provides a top-downand bottom-up view of an organization's security posture.

The enterprise security application leverages the data intake and querysystem 108 search-time normalization techniques, saved searches, andcorrelation searches to provide visibility into security-relevantthreats and activity and generate notable events for tracking. Theenterprise security application enables the security practitioner toinvestigate and explore the data to find new or unknown threats that donot follow signature-based patterns.

Conventional Security Information and Event Management (SIEM) systemslack the infrastructure to effectively store and analyze large volumesof security-related data. Traditional SIEM systems typically use fixedschemas to extract data from pre-defined security-related fields at dataingestion time and store the extracted data in a relational database.This traditional data extraction process (and associated reduction indata size) that occurs at data ingestion time inevitably hampers futureincident investigations that may need original data to determine theroot cause of a security issue, or to detect the onset of an impendingsecurity threat.

In contrast, the enterprise security application system stores largevolumes of minimally-processed security-related data at ingestion timefor later retrieval and analysis at search time when a live securitythreat is being investigated. To facilitate this data retrieval process,the enterprise security application provides pre-specified schemas forextracting relevant values from the different types of security-relatedevents and enables a user to define such schemas.

The enterprise security application can process many types ofsecurity-related information. In general, this security-relatedinformation can include any information that can be used to identifysecurity threats. For example, the security-related information caninclude network-related information, such as IP addresses, domain names,asset identifiers, network traffic volume, uniform resource locatorstrings, and source addresses. The process of detecting security threatsfor network-related information is further described in U.S. Pat. No.8,826,434, entitled “SECURITY THREAT DETECTION BASED ON INDICATIONS INBIG DATA OF ACCESS TO NEWLY REGISTERED DOMAINS”, issued on 2 Sep. 2014,U.S. Pat. No. 9,215,240, entitled “INVESTIGATIVE AND DYNAMIC DETECTIONOF POTENTIAL SECURITY-THREAT INDICATORS FROM EVENTS IN BIG DATA”, issuedon 15 Dec. 2015, U.S. Pat. No. 9,173,801, entitled “GRAPHIC DISPLAY OFSECURITY THREATS BASED ON INDICATIONS OF ACCESS TO NEWLY REGISTEREDDOMAINS”, issued on 3 Nov. 2015, U.S. Pat. No. 9,248,068, entitled“SECURITY THREAT DETECTION OF NEWLY REGISTERED DOMAINS”, issued on 2Feb. 2016, U.S. Pat. No. 9,426,172, entitled “SECURITY THREAT DETECTIONUSING DOMAIN NAME ACCESSES”, issued on 23 Aug. 2016, and U.S. Pat. No.9,432,396, entitled “SECURITY THREAT DETECTION USING DOMAIN NAMEREGISTRATIONS”, issued on 30 Aug. 2016, each of which is herebyincorporated by reference in its entirety for all purposes.Security-related information can also include malware infection data andsystem configuration information, as well as access control information,such as login/logout information and access failure notifications. Thesecurity-related information can originate from various sources within adata center, such as hosts, virtual machines, storage devices andsensors. The security-related information can also originate fromvarious sources in a network, such as routers, switches, email servers,proxy servers, gateways, firewalls and intrusion-detection systems.

During operation, the enterprise security application facilitatesdetecting “notable events” that are likely to indicate a securitythreat. A notable event represents one or more anomalous incidents, theoccurrence of which can be identified based on one or more events (e.g.,time stamped portions of raw machine data) fulfilling pre-specifiedand/or dynamically-determined (e.g., based on machine-learning) criteriadefined for that notable event. Examples of notable events include therepeated occurrence of an abnormal spike in network usage over a periodof time, a single occurrence of unauthorized access to system, a hostcommunicating with a server on a known threat list, and the like. Thesenotable events can be detected in a number of ways, such as: (1) a usercan notice a correlation in events and can manually identify that acorresponding group of one or more events amounts to a notable event; or(2) a user can define a “correlation search” specifying criteria for anotable event, and every time one or more events satisfy the criteria,the application can indicate that the one or more events correspond to anotable event; and the like. A user can alternatively select apre-defined correlation search provided by the application. Note thatcorrelation searches can be run continuously or at regular intervals(e.g., every hour) to search for notable events. Upon detection, notableevents can be stored in a dedicated “notable events index,” which can besubsequently accessed to generate various visualizations containingsecurity-related information. Also, alerts can be generated to notifysystem operators when important notable events are discovered.

The enterprise security application provides various visualizations toaid in discovering security threats, such as a “key indicators view”that enables a user to view security metrics, such as counts ofdifferent types of notable events. For example, FIG. 28A illustrates anexample key indicators view 2800 that comprises a dashboard, which candisplay a value 2801, for various security-related metrics, such asmalware infections 2802. It can also display a change in a metric value2803, which indicates that the number of malware infections increased by63 during the preceding interval. Key indicators view 2800 additionallydisplays a histogram panel 2804 that displays a histogram of notableevents organized by urgency values, and a histogram of notable eventsorganized by time intervals. This key indicators view is described infurther detail in pending U.S. patent application Ser. No. 13/956,338,entitled “KEY INDICATORS VIEW”, filed on 31 Jul. 2013, and which ishereby incorporated by reference in its entirety for all purposes.

These visualizations can also include an “incident review dashboard”that enables a user to view and act on “notable events.” These notableevents can include: (1) a single event of high importance, such as anyactivity from a known web attacker; or (2) multiple events thatcollectively warrant review, such as a large number of authenticationfailures on a host followed by a successful authentication. For example,FIG. 28B illustrates an example incident review dashboard 2810 thatincludes a set of incident attribute fields 2811 that, for example,enables a user to specify a time range field 2812 for the displayedevents. It also includes a timeline 2813 that graphically illustratesthe number of incidents that occurred in time intervals over theselected time range. It additionally displays an events list 2814 thatenables a user to view a list of all of the notable events that matchthe criteria in the incident attributes fields 2811. To facilitateidentifying patterns among the notable events, each notable event can beassociated with an urgency value (e.g., low, medium, high, critical),which is indicated in the incident review dashboard. The urgency valuefor a detected event can be determined based on the severity of theevent and the priority of the system component associated with theevent.

4.14. Data Center Monitoring

As mentioned above, the data intake and query platform provides variousfeatures that simplify the developer's task to create variousapplications. One such application is a virtual machine monitoringapplication, such as SPLUNK® APP FOR VMWARE® that provides operationalvisibility into granular performance metrics, logs, tasks and events,and topology from hosts, virtual machines and virtual centers. Itempowers administrators with an accurate real-time picture of the healthof the environment, proactively identifying performance and capacitybottlenecks.

Conventional data-center-monitoring systems lack the infrastructure toeffectively store and analyze large volumes of machine-generated data,such as performance information and log data obtained from the datacenter. In conventional data-center-monitoring systems,machine-generated data is typically pre-processed prior to being stored,for example, by extracting pre-specified data items and storing them ina database to facilitate subsequent retrieval and analysis at searchtime. However, the rest of the data is not saved and discarded duringpre-processing.

In contrast, the virtual machine monitoring application stores largevolumes of minimally processed machine data, such as performanceinformation and log data, at ingestion time for later retrieval andanalysis at search time when a live performance issue is beinginvestigated. In addition to data obtained from various log files, thisperformance-related information can include values for performancemetrics obtained through an application programming interface (API)provided as part of the vSphere Hypervisor™ system distributed byVMware, Inc. of Palo Alto, Calif. For example, these performance metricscan include: (1) CPU-related performance metrics; (2) disk-relatedperformance metrics; (3) memory-related performance metrics; (4)network-related performance metrics; (5) energy-usage statistics; (6)data-traffic-related performance metrics; (7) overall systemavailability performance metrics; (8) cluster-related performancemetrics; and (9) virtual machine performance statistics. Suchperformance metrics are described in U.S. patent application Ser. No.14/167,316, entitled “CORRELATION FOR USER-SELECTED TIME RANGES OFVALUES FOR PERFORMANCE METRICS OF COMPONENTS IN ANINFORMATION-TECHNOLOGY ENVIRONMENT WITH LOG DATA FROM THATINFORMATION-TECHNOLOGY ENVIRONMENT”, filed on 29 Jan. 2014, and which ishereby incorporated by reference in its entirety for all purposes.

To facilitate retrieving information of interest from performance dataand log files, the virtual machine monitoring application providespre-specified schemas for extracting relevant values from differenttypes of performance-related events, and also enables a user to definesuch schemas.

The virtual machine monitoring application additionally provides variousvisualizations to facilitate detecting and diagnosing the root cause ofperformance problems. For example, one such visualization is a“proactive monitoring tree” that enables a user to easily view andunderstand relationships among various factors that affect theperformance of a hierarchically structured computing system. Thisproactive monitoring tree enables a user to easily navigate thehierarchy by selectively expanding nodes representing various entities(e.g., virtual centers or computing clusters) to view performanceinformation for lower-level nodes associated with lower-level entities(e.g., virtual machines or host systems). Example node-expansionoperations are illustrated in FIG. 28C, wherein nodes 2833 and 2834 areselectively expanded. Note that nodes 2831-2839 can be displayed usingdifferent patterns or colors to represent different performance states,such as a critical state, a warning state, a normal state or anunknown/offline state. The ease of navigation provided by selectiveexpansion in combination with the associated performance-stateinformation enables a user to quickly diagnose the root cause of aperformance problem. The proactive monitoring tree is described infurther detail in U.S. Pat. No. 9,185,007, entitled “PROACTIVEMONITORING TREE WITH SEVERITY STATE SORTING”, issued on 10 Nov. 2015,and U.S. Pat. No. 9,426,045, also entitled “PROACTIVE MONITORING TREEWITH SEVERITY STATE SORTING”, issued on 23 Aug. 2016, each of which ishereby incorporated by reference in its entirety for all purposes.

The virtual machine monitoring application also provides a userinterface that enables a user to select a specific time range and thenview heterogeneous data comprising events, log data, and associatedperformance metrics for the selected time range. For example, the screenillustrated in FIG. 28D displays a listing of recent “tasks and events”and a listing of recent “log entries” for a selected time range above aperformance-metric graph for “average CPU core utilization” for theselected time range. Note that a user is able to operate pull-down menus2842 to selectively display different performance metric graphs for theselected time range. This enables the user to correlate trends in theperformance-metric graph with corresponding event and log data toquickly determine the root cause of a performance problem. This userinterface is described in more detail in U.S. patent application Ser.No. 14/167,316, entitled “CORRELATION FOR USER-SELECTED TIME RANGES OFVALUES FOR PERFORMANCE METRICS OF COMPONENTS IN ANINFORMATION-TECHNOLOGY ENVIRONMENT WITH LOG DATA FROM THATINFORMATION-TECHNOLOGY ENVIRONMENT”, filed on 29 Jan. 2014, and which ishereby incorporated by reference in its entirety for all purposes.

4.15. It Service Monitoring

As previously mentioned, the data intake and query platform providesvarious schemas, dashboards and visualizations that make it easy fordevelopers to create applications to provide additional capabilities.One such application is an IT monitoring application, such as SPLUNK® ITSERVICE INTELLIGENCE™, which performs monitoring and alertingoperations. The IT monitoring application also includes analytics tohelp an analyst diagnose the root cause of performance problems based onlarge volumes of data stored by the data intake and query system 108 ascorrelated to the various services an IT organization provides (aservice-centric view). This differs significantly from conventional ITmonitoring systems that lack the infrastructure to effectively store andanalyze large volumes of service-related events. Traditional servicemonitoring systems typically use fixed schemas to extract data frompre-defined fields at data ingestion time, wherein the extracted data istypically stored in a relational database. This data extraction processand associated reduction in data content that occurs at data ingestiontime inevitably hampers future investigations, when all of the originaldata may be needed to determine the root cause of or contributingfactors to a service issue.

In contrast, an IT monitoring application system stores large volumes ofminimally-processed service-related data at ingestion time for laterretrieval and analysis at search time, to perform regular monitoring, orto investigate a service issue. To facilitate this data retrievalprocess, the IT monitoring application enables a user to define an IToperations infrastructure from the perspective of the services itprovides. In this service-centric approach, a service such as corporatee-mail may be defined in terms of the entities employed to provide theservice, such as host machines and network devices. Each entity isdefined to include information for identifying all of the events thatpertains to the entity, whether produced by the entity itself or byanother machine, and considering the many various ways the entity may beidentified in machine data (such as by a URL, an IP address, or machinename). The service and entity definitions can organize events around aservice so that all of the events pertaining to that service can beeasily identified. This capability provides a foundation for theimplementation of Key Performance Indicators.

One or more Key Performance Indicators (KPI's) are defined for a servicewithin the IT monitoring application. Each KPI measures an aspect ofservice performance at a point in time or over a period of time (aspectKPI's). Each KPI is defined by a search query that derives a KPI valuefrom the machine data of events associated with the entities thatprovide the service. Information in the entity definitions may be usedto identify the appropriate events at the time a KPI is defined orwhenever a KPI value is being determined. The KPI values derived overtime may be stored to build a valuable repository of current andhistorical performance information for the service, and the repository,itself, may be subject to search query processing. Aggregate KPIs may bedefined to provide a measure of service performance calculated from aset of service aspect KPI values; this aggregate may even be takenacross defined timeframes and/or across multiple services. A particularservice may have an aggregate KPI derived from substantially all of theaspect KPI's of the service to indicate an overall health score for theservice.

The IT monitoring application facilitates the production of meaningfulaggregate KPI's through a system of KPI thresholds and state values.Different KPI definitions may produce values in different ranges, and sothe same value may mean something very different from one KPI definitionto another. To address this, the IT monitoring application implements atranslation of individual KPI values to a common domain of “state”values. For example, a KPI range of values may be 1-100, or 50-275,while values in the state domain may be ‘critical,’ ‘warning,’ normal;and ‘informational’. Thresholds associated with a particular KPIdefinition determine ranges of values for that KPI that correspond tothe various state values. In one case, KPI values 95-100 may be set tocorrespond to ‘critical’ in the state domain. KPI values from disparateKPI's can be processed uniformly once they are translated into thecommon state values using the thresholds. For example, “normal 80% ofthe time” can be applied across various KPI's. To provide meaningfulaggregate KPI's, a weighting value can be assigned to each KPI so thatits influence on the calculated aggregate KPI value is increased ordecreased relative to the other KPI's.

One service in an IT environment often impacts, or is impacted by,another service. The IT monitoring application can reflect thesedependencies. For example, a dependency relationship between a corporatee-mail service and a centralized authentication service can be reflectedby recording an association between their respective servicedefinitions. The recorded associations establish a service dependencytopology that informs the data or selection options presented in a GUI,for example. (The service dependency topology is like a “map” showinghow services are connected based on their dependencies.) The servicetopology may itself be depicted in a GUI and may be interactive to allownavigation among related services.

Entity definitions in the IT monitoring application can includeinformational fields that can serve as metadata, implied data fields, orattributed data fields for the events identified by other aspects of theentity definition. Entity definitions in the IT monitoring applicationcan also be created and updated by an import of tabular data (asrepresented in a CSV, another delimited file, or a search query resultset). The import may be GUI-mediated or processed using importparameters from a GUI-based import definition process. Entitydefinitions in the IT monitoring application can also be associated witha service by means of a service definition rule. Processing the ruleresults in the matching entity definitions being associated with theservice definition. The rule can be processed at creation time, andthereafter on a scheduled or on-demand basis. This allows dynamic,rule-based updates to the service definition.

During operation, the IT monitoring application can recognize notableevents that may indicate a service performance problem or othersituation of interest. These notable events can be recognized by a“correlation search” specifying trigger criteria for a notable event:every time KPI values satisfy the criteria, the application indicates anotable event. A severity level for the notable event may also bespecified. Furthermore, when trigger criteria are satisfied, thecorrelation search may additionally or alternatively cause a serviceticket to be created in an IT service management (ITSM) system, such asa systems available from ServiceNow, Inc., of Santa Clara, Calif.

SPLUNK® IT SERVICE INTELLIGENCE™ provides various visualizations builton its service-centric organization of events and the KPI valuesgenerated and collected. Visualizations can be particularly useful formonitoring or investigating service performance. The IT monitoringapplication provides a service monitoring interface suitable as the homepage for ongoing IT service monitoring. The interface is appropriate forsettings such as desktop use or for a wall-mounted display in a networkoperations center (NOC). The interface may prominently display aservices health section with tiles for the aggregate KPI's indicatingoverall health for defined services and a general KPI section with tilesfor KPI's related to individual service aspects. These tiles may displayKPI information in a variety of ways, such as by being colored andordered according to factors like the KPI state value. They also can beinteractive and navigate to visualizations of more detailed KPIinformation.

The IT monitoring application provides a service-monitoring dashboardvisualization based on a user-defined template. The template can includeuser-selectable widgets of varying types and styles to display KPIinformation. The content and the appearance of widgets can responddynamically to changing KPI information. The KPI widgets can appear inconjunction with a background image, user drawing objects, or othervisual elements, that depict the IT operations environment, for example.The KPI widgets or other GUI elements can be interactive so as toprovide navigation to visualizations of more detailed KPI information.

The IT monitoring application provides a visualization showing detailedtime-series information for multiple KPI's in parallel graph lanes. Thelength of each lane can correspond to a uniform time range, while thewidth of each lane may be automatically adjusted to fit the displayedKPI data. Data within each lane may be displayed in a user selectablestyle, such as a line, area, or bar chart. During operation a user mayselect a position in the time range of the graph lanes to activate laneinspection at that point in time. Lane inspection may display anindicator for the selected time across the graph lanes and display theKPI value associated with that point in time for each of the graphlanes. The visualization may also provide navigation to an interface fordefining a correlation search, using information from the visualizationto pre-populate the definition.

The IT monitoring application provides a visualization for incidentreview showing detailed information for notable events. The incidentreview visualization may also show summary information for the notableevents over a time frame, such as an indication of the number of notableevents at each of a number of severity levels. The severity leveldisplay may be presented as a rainbow chart with the warmest colorassociated with the highest severity classification. The incident reviewvisualization may also show summary information for the notable eventsover a time frame, such as the number of notable events occurring withinsegments of the time frame. The incident review visualization maydisplay a list of notable events within the time frame ordered by anynumber of factors, such as time or severity. The selection of aparticular notable event from the list may display detailed informationabout that notable event, including an identification of the correlationsearch that generated the notable event.

The IT monitoring application provides pre-specified schemas forextracting relevant values from the different types of service-relatedevents. It also enables a user to define such schemas.

4.16. Other Architectures

In view of the description above, it will be appreciate that thearchitecture disclosed herein, or elements of that architecture, may beimplemented independently from, or in conjunction with, otherarchitectures. For example, the Incorporated Applications disclose avariety of architectures wholly or partially compatible with thearchitecture of the present disclosure.

Generally speaking one or more components of the data intake and querysystem 108 of the present disclosure can be used in combination with orto replace one or more components of the data intake and query system108 of the Incorporated Applications. For example, depending on theembodiment, the operations of the forwarder 204 and the ingestion buffer4802 of the Incorporated Applications can be performed by or replacedwith the intake system 210 of the present disclosure. The parsing,indexing, and storing operations (or other non-searching operations) ofthe indexers 206, 230 and indexing cache components 254 of theIncorporated Applications can be performed by or replaced with theindexing nodes 404 of the present disclosure. The storage operations ofthe data stores 208 of the Incorporated Applications can be performedusing the data stores 412 of the present disclosure (in some cases withthe data not being moved to common storage 216). The storage operationsof the common storage 4602, cloud storage 256, or global index 258 canbe performed by the common storage 216 of the present disclosure. Thestorage operations of the query acceleration data store 3308 can beperformed by the query acceleration data store 222 of the presentdisclosure.

As continuing examples, the search operations of the indexers 206, 230and indexing cache components 254 of the Incorporated Applications canbe performed by or replaced with the indexing nodes 404 in someembodiments or by the search nodes 506 in certain embodiments. Forexample, in some embodiments of certain architectures of theIncorporated Applications (e.g., one or more embodiments related toFIGS. 2, 3, 4, 18, 25, 27, 33, 46), the indexers 206, 230 and indexingcache components 254 of the Incorporated Applications may performparsing, indexing, storing, and at least some searching operations, andin embodiments of some architectures of the Incorporated Applications(e.g., one more embodiments related to FIG. 48), indexers 206, 230 andindexing cache components 254 of the Incorporated Applications performparsing, indexing, and storing operations, but do not perform searchingoperations. Accordingly, in some embodiments, some or all of thesearching operations described as being performed by the indexers 206,230 and indexing cache components 254 of the Incorporated Applicationscan be performed by the search nodes 506. For example, in embodimentsdescribed in the Incorporated Applications in which worker nodes 214,236, 246, 3306 perform searching operations in place of the indexers206, 230 or indexing cache components 254, the search nodes 506 canperform those operations. In certain embodiments, some or all of thesearching operations described as being performed by the indexers 206,230 and indexing cache components 254 of the Incorporated Applicationscan be performed by the indexing nodes 404. For example, in embodimentsdescribed in the Incorporated Applications in which the indexers 206,230 and indexing cache components 254 perform searching operations, theindexing nodes 404 can perform those operations.

As a further example, the query operations performed by the search heads210, 226, 244, daemons 210, 232, 252, search master 212, 234, 250,search process master 3302, search service provider 216, and querycoordinator 3304 of the Incorporated Applications, can be performed byor replaced with any one or any combination of the query system manager502, search head 504, search master 512, search manager 514, resourcemonitor 508, and/or the resource catalog 510. For example, thesecomponents can handle and coordinate the intake of queries, queryprocessing, identification of available nodes and resources, resourceallocation, query execution plan generation, assignment of queryoperations, combining query results, and providing query results to auser or a data store.

In certain embodiments, the query operations performed by the workernodes 214, 236, 246, 3306 of the Incorporated Applications can beperformed by or replaced with the search nodes 506 of the presentdisclosure. In some embodiments, the intake or ingestion operationsperformed by the worker nodes 214, 236, 246, 3306 of the IncorporatedApplications can be performed by or replaced with one or more componentsof the intake system 210.

Furthermore, it will be understood that some or all of the components ofthe architectures of the Incorporated Applications can be replaced withcomponents of the present disclosure. For example, in certainembodiments, the intake system 210 can be used in place of theforwarders 204 and/or ingestion buffer 4802 of one or more architecturesof the Incorporated Applications, with all other components of the oneor more architecture of the Incorporated Applications remaining thesame. As another example, in some embodiments the indexing nodes 404 canreplace the indexer 206 of one or more architectures of the IncorporatedApplications with all other components of the one or more architecturesof the Incorporated Applications remaining the same. Accordingly, itwill be understood that a variety of architectures can be designed usingone or more components of the data intake and query system 108 of thepresent disclosure in combination with one or more components of thedata intake and query system 108 of the Incorporated Applications.

Illustratively, the architecture depicted at FIG. 2 of the IncorporatedApplications may be modified to replace the forwarder 204 of thatarchitecture with the intake system 210 of the present disclosure. Inaddition, in some cases, the indexers 206 of the IncorporatedApplications can be replaced with the indexing nodes 404 of the presentdisclosure. In such embodiments, the indexing nodes 404 can retain thebuckets in the data stores 412 that they create rather than store thebuckets in common storage 216. Further, in the architecture depicted atFIG. 2 of the Incorporated Applications, the indexing nodes 404 of thepresent disclosure can be used to execute searches on the buckets storedin the data stores 412. In some embodiments, in the architecturedepicted at FIG. 2 of the Incorporated Applications, the partitionmanager 408 can receive data from one or more forwarders 204 of theIncorporated Applications. As additional forwarders 204 are added or asadditional data is supplied to the architecture depicted at FIG. 2 ofthe Incorporated Applications, the indexing node 404 can spawnadditional partition manager 408 and/or the indexing manager system 402can spawn additional indexing nodes 404. In addition, in certainembodiments, the bucket manager 414 may merge buckets in the data store414 or be omitted from the architecture depicted at FIG. 2 of theIncorporated Applications.

Furthermore, in certain embodiments, the search head 210 of theIncorporated Applications can be replaced with the search head 504 ofthe present disclosure. In some cases, as described herein, the searchhead 504 can use the search master 512 and search manager 514 to processand manager the queries. However, rather than communicating with searchnodes 506 to execute a query, the search head 504 can, depending on theembodiment, communicate with the indexers 206 of the IncorporatedApplications or the search nodes 404 to execute the query.

Similarly the architecture of FIG. 3 of the Incorporated Applicationsmay be modified in a variety of ways to include one or more componentsof the data intake and query system 108 described herein. For example,the architecture of FIG. 3 of the Incorporated Applications may bemodified to include an intake system 210 in accordance with the presentdisclosure within the cloud-based data intake and query system 1006 ofthe Incorporated Applications, which intake system 210 may logicallyinclude or communicate with the forwarders 204 of the IncorporatedApplications. In addition, the indexing nodes 404 described herein maybe utilized in place of or to implement functionality similar to theindexers described with reference to FIG. 3 of the IncorporatedApplications. In addition, the architecture of FIG. 3 of theIncorporated Applications may be modified to include common storage 216and/or search nodes 506.

With respect to the architecture of FIGS. 4A and/or 4B of theIncorporated Applications, the intake system 210 described herein may beutilized in place of or to implement functionality similar to either orboth the forwarders 204 or the ERP processes 410 through 412 of theIncorporated Applications. Similarly, the indexing nodes 404 and thesearch head 504 described herein may be utilized in place of or toimplement functionality similar to the indexer 206 and search head 210,respectively. In some cases, the search manager 514 described herein canmanage the communications and interfacing between the indexer 206 andthe ERP processes 410 through 412.

With respect to the flow diagrams and functionality described in FIGS.5A-5C, 6A, 6B, 7A-7D, 8A, 8B, 9, 10, 11A-11D, 12-16, and 17A-17D of theIncorporated Applications, it will be understood that the processing andindexing operations described as being performed by the indexers 206 canbe performed by the indexing nodes 404, the search operations describedas being performed by the indexers 206 can be performed by the indexingnodes 404 or search nodes 506 (depending on the embodiment), and/or thesearching operations described as being performed by the search head210, can be performed by the search head 504 or other component of thequery system 214.

With reference to FIG. 18 of the Incorporated Applications, the indexingnodes 404 and search heads 504 described herein may be utilized in placeof or to implement functionality similar to the indexers 206 and searchhead 210, respectively. Similarly, the search master 512 and searchmanager 514 described herein may be utilized in place of or to implementfunctionality similar to the master 212 and the search service provider216, respectively, described with respect to FIG. 18 of the IncorporatedApplications. Further, the intake system 210 described herein may beutilized in place of or to implement ingestion functionality similar tothe ingestion functionality of the worker nodes 214 of the IncorporatedApplications. Similarly, the search nodes 506 described herein may beutilized in place of or to implement search functionality similar to thesearch functionality of the worker nodes 214 of the IncorporatedApplications.

With reference to FIG. 25 of the Incorporated Applications, the indexingnodes 404 and search heads 504 described herein may be utilized in placeof or to implement functionality similar to the indexers 236 and searchheads 226, respectively. In addition, the search head 504 describedherein may be utilized in place of or to implement functionality similarto the daemon 232 and the master 234 described with respect to FIG. 25of the Incorporated Applications. The intake system 210 described hereinmay be utilized in place of or to implement ingestion functionalitysimilar to the ingestion functionality of the worker nodes 214 of theIncorporated Applications. Similarly, the search nodes 506 describedherein may be utilized in place of or to implement search functionalitysimilar to the search functionality of the worker nodes 234 of theIncorporated Applications.

With reference to FIG. 27 of the Incorporated Applications, the indexingnodes 404 or search nodes 506 described herein may be utilized in placeof or to implement functionality similar to the index cache components254. For example, the indexing nodes 404 may be utilized in place of orto implement parsing, indexing, storing functionality of the index cachecomponents 254, and the search nodes 506 described herein may beutilized in place of or to implement searching or caching functionalitysimilar to the index cache components 254. In addition, the search head504 described herein may be utilized in place of or to implementfunctionality similar to the search heads 244, daemon 252, and/or themaster 250 described with respect to FIG. 27 of the IncorporatedApplications. The intake system 210 described herein may be utilized inplace of or to implement ingestion functionality similar to theingestion functionality of the worker nodes 246 described with respectto FIG. 27 of the Incorporated Applications. Similarly, the search nodes506 described herein may be utilized in place of or to implement searchfunctionality similar to the search functionality of the worker nodes234 described with respect to FIG. 27 of the Incorporated Applications.In addition, the common storage 216 described herein may be utilized inplace of or to implement functionality similar to the functionality ofthe cloud storage 256 and/or global index 258 described with respect toFIG. 27 of the Incorporated Applications.

With respect to the architectures of FIGS. 33, 46, and 48 of theIncorporated Applications, the intake system 210 described herein may beutilized in place of or to implement functionality similar to theforwarders 204. In addition, the indexing nodes 404 of the presentdisclosure can perform the functions described as being performed by theindexers 206 (e.g., parsing, indexing, storing, and in some embodiments,searching) of the architectures of FIGS. 33, 46, and 48 of theIncorporated Applications; the operations of the acceleration data store3308 of the architectures of FIGS. 33, 46, and 48 of the IncorporatedApplications can be performed by the acceleration data store 222 of thepresent application; and the operations of the search head 210, searchprocess maser 3302, and query coordinator 3304 of the architectures ofFIGS. 33, 46, and 48 of the Incorporated Applications can be performedby the search head 504, resource catalog 510, and or resource monitor508 of the present application. For example, the functionality of theworkload catalog 3312 and node monitor 3314 of the architectures ofFIGS. 33, 46, and 48 of the Incorporated Applications can be performedby the resource catalog 510 and resource monitor 508; the functionalityof the search head 210 and other components of the search process master3302 of the architectures of FIGS. 33, 46, and 48 of the IncorporatedApplications can be performed by the search head 504 or search master512; and the functionality of the query coordinator 3304 of thearchitectures of FIGS. 33, 46, and 48 of the Incorporated Applicationscan be performed by the search manager 514.

In addition, in some embodiments, the searching operations described asbeing performed by the worker nodes 3306 of the architectures of FIGS.33, 46, and 48 of the Incorporated Applications can be performed by thesearch nodes 506 of the present application and the intake or ingestionoperations performed by the worker nodes 3306 of the architectures ofFIGS. 33, 46, and 48 of the Incorporated Applications can be performedby the intake system 210. However, it will be understood that in someembodiments, the search nodes 506 can perform the intake and searchoperations described in the Incorporated Applications as being performedby the worker nodes 3306. Furthermore, the cache manager 516 canimplement one or more of the caching operations described in theIncorporated Applications with reference to the architectures of FIGS.33, 46, and 48 of the Incorporated Applications.

With respect to FIGS. 46 and 48 of the Incorporated Applications, thecommon storage 216 of the present application can be used to provide thefunctionality with respect to the common storage 2602 of thearchitecture of FIGS. 46 and 48 of the Incorporated Applications. Withrespect to the architecture of FIG. 48 of the Incorporated Applications,the intake system 210 described herein may be utilized in place of or toimplement operations similar to the forwarders 204 and ingested databuffer 4802, and may in some instances implement all or a portion of theoperations described in that reference with respect to worker nodes3306. Thus, the architecture of the present disclosure, or componentsthereof, may be implemented independently from or incorporated withinarchitectures of the prior disclosures.

5.0 Example Embodiments

Embodiments of the present disclosure can be described in view of thefollowing clauses:

-   -   Clause 1. A method, comprising:        -   maintaining, by a data intake and query system, a resource            catalog, the resource catalog identifying containerized            indexing nodes instantiated in the data intake and query            system, wherein the resource catalog is maintained based on            one or more communications with each of the containerized            indexing nodes;        -   receiving, from a partition manager of the data intake and            query system, a request for a containerized indexing node            that the partition manager can assign to process data            received by the partition manager;        -   identifying, based on the resource catalog, an available            containerized indexing node to process the data; and        -   communicating, to the partition manager, an indexing node            identifier associated with the available containerized            indexing node, wherein the partition manager communicates            the data to the available containerized indexing node based            on the indexing node identifier, wherein the available            containerized indexing node processes the data and stores            results in one or more data stores.    -   Clause 2. The method of clause 1, further comprising:        -   communicating with at least one of the containerized            indexing nodes instantiated in the data intake and query            system to receive metrics data; and        -   updating the resource catalog to include the metrics data.    -   Clause 3. The method of any of the previous clauses, further        comprising:        -   individually pinging at least one containerized indexing            node to receive metrics data; and        -   updating the resource catalog to include the metrics data.    -   Clause 4. The method of any of the previous clauses, further        comprising:        -   individually pinging at least one containerized indexing            node at a predetermined interval to receive metrics data;            and        -   updating the resource catalog to include the metrics data.    -   Clause 5. The method of any of the previous clauses, wherein        said identifying the available containerized indexing node is        based on metrics data in the resource catalog.    -   Clause 6. The method of any of the previous clauses, wherein        said identifying the available containerized indexing node is        based on metrics data in the resource catalog, wherein the        metrics data includes at least one of a utilization rate, an        amount of processing resources in use, or an amount of memory        used.    -   Clause 7. The method of any of the previous clauses, wherein the        data comprises raw machine data.    -   Clause 8. The method of any of the previous clauses, wherein the        data includes a reference to other data stored in a data store,        and wherein to process the data, the available containerized        indexing node is configured to:        -   obtain the other data stored in the data store based on the            reference; and        -   process the other data to generate one or more events.    -   Clause 9. The method of any of the previous clauses, wherein the        data includes a reference to other data stored in a data store,        wherein the results include at least a portion of the other data        obtained from the data store.    -   Clause 10. The method of any of the previous clauses, further        comprising:        -   identifying, based on the request, a tenant identifier            associated with the data,        -   wherein said identifying the available containerized            indexing node is further based on the tenant identifier.    -   Clause 11. The method of any of the previous clauses, further        comprising:        -   identifying, from the request, a tenant identifier            associated with the data,        -   wherein said identifying the available containerized            indexing node is further based on the tenant identifier.    -   Clause 12. The method of any of the previous clauses, further        comprising identifying a tenant identifier associated with the        data, wherein the tenant identifier uniquely identifies a        particular tenant from a plurality of tenants associated with        the data intake and query system.    -   Clause 13. The method of any of the previous clauses, wherein        the request includes a reference to other data stored in a data        store, the method further comprising:        -   retrieving the other data; and        -   identifying a tenant identifier from the other data,        -   wherein said identifying the available containerized            indexing node is further based on the tenant identifier.    -   Clause 14. The method of any of the previous clauses, wherein        said identifying the available containerized indexing node        comprises mapping the available containerized indexing node to a        tenant identifier associated with the data.    -   Clause 15. The method of any of the previous clauses, wherein        said identifying the available containerized indexing node        comprises mapping the available containerized indexing node to a        tenant identifier associated with the data, the method further        comprising updating the resource catalog to include an        indication of said mapping.    -   Clause 16. The method of any of the previous clauses, further        comprising identifying the tenant identifier from the request,        wherein said identifying the available containerized indexing        node is further based on the tenant identifier.    -   Clause 17. The method of any of the previous clauses, wherein        said identifying the available containerized indexing node        comprises:        -   identifying a tenant identifier associated with the data;        -   hashing the tenant identifier using a hash function; and        -   identifying the available containerized indexing node from            other containerized indexing node of the containerized            indexing nodes based on a result of said hashing.    -   Clause 18. The method of any of the previous clauses, wherein        said identifying the available containerized indexing node        comprises:        -   hashing a tenant identifier using a consistent hash            function; and        -   identifying the available containerized indexing node from            other containerized indexing node of the containerized            indexing nodes based on a result of said hashing.    -   Clause 19. The method of any of the previous clauses, wherein        said identifying the available containerized indexing node        comprises:        -   determining a tenant identifier hash value based on a hash            of a tenant identifier associated with the data;        -   determining a plurality of indexing node hash values based            on a hash of a plurality of indexing node identifiers,            wherein each of the plurality of indexing node identifiers            is associated with a respective one of the containerized            indexing nodes; and        -   identifying the available containerized indexing node based            on a proximity of the tenant identifier hash value to one of            the indexing node hash values.    -   Clause 20. The method of any of the previous clauses, wherein        said identifying the available containerized indexing node        comprises:        -   determining a tenant identifier hash value based on a hash            of a tenant identifier associated with the data;        -   determining a plurality of indexing node hash values based            on a hash of a plurality of indexing node identifiers,            wherein each of the plurality of indexing node identifiers            is associated with a respective one of the containerized            indexing nodes; and        -   identifying the available containerized indexing node based            on a proximity of the tenant identifier hash value to one of            the plurality of indexing node hash values on a hash ring.    -   Clause 21. The method of any of the previous clauses, wherein        the available containerized indexing node comprises at least two        of the containerized indexing nodes instantiated in the data        intake and query system.    -   Clause 22. The method of any of the previous clauses, wherein        the results include a plurality of events generated by the        available containerized indexing node.    -   Clause 23. The method of any of the previous clauses, wherein        the results include a plurality of events generated by the        available containerized indexing node, each of the plurality of        events including raw machine data associated with a timestamp.    -   Clause 24. The method of any of the previous clauses, wherein        the request for a containerized indexing node is received based        on a determination by the partition manager that a tenant        identifier associated with the data is not associated with one        of the containerized indexing nodes.    -   Clause 25. The method of any of the previous clauses, further        comprising generating an indexing node in response to the        request for a containerized indexing node, wherein the available        containerized indexing node is the generated indexing node.    -   Clause 26. The method of any of the previous clauses, further        comprising generating an indexing node in response to the        request for a containerized indexing node and based on a        determination that no containerized indexing nodes of the        containerized indexing nodes instantiated in the data intake and        query system are available, wherein the available containerized        indexing node is the generated indexing node.    -   Clause 27. The method of any of the previous clauses, wherein        said identifying the available containerized indexing node        further comprises:        -   identifying metrics corresponding to at least some of the            containerized indexing nodes of the containerized indexing            nodes instantiated in the data intake and query system, and        -   determining that no containerized indexing nodes of the            containerized indexing nodes instantiated in the data intake            and query system are available based on the metrics.    -   Clause 28. A computing system of a data intake and query system,        the computing system comprising:        -   memory; and        -   one or more processing devices coupled to the memory and            configured to:            -   maintain a resource catalog, the resource catalog                identifying containerized indexing nodes instantiated in                the data intake and query system, wherein the resource                catalog is maintained based on one or more                communications with each of the containerized indexing                nodes;            -   receive, from a partition manager of the data intake and                query system, a request for a containerized indexing                node that the partition manager can assign to process                data received by the partition manager;            -   identify, based on the resource catalog, an available                containerized indexing node to process the data; and            -   communicate, to the partition manager, an indexing node                identifier associated with the available containerized                indexing node, wherein the partition manager                communicates the data to the available containerized                indexing node based on the indexing node identifier,                wherein the available containerized indexing node                processes the data and stores results in one or more                data stores.    -   Clause 29. The system of clause 28, wherein the one or more        processing devices are further configured to:        -   identify, from the request, a tenant identifier associated            with the data,        -   wherein to identify the available containerized indexing            node, the one or more processing devices are configured to            identify the available containerized indexing node based on            the tenant identifier.    -   Clause 30. Non-transitory computer readable media comprising        computer-executable instructions that, when executed by a        computing system of a data intake and query system, cause the        computing system to:        -   maintain a resource catalog, the resource catalog            identifying containerized indexing nodes instantiated in the            data intake and query system, wherein the resource catalog            is maintained based on one or more communications with each            of the containerized indexing nodes;        -   receive, from a partition manager of the data intake and            query system, a request for a containerized indexing node            that the partition manager can assign to process data            received by the partition manager;        -   identify, based on the resource catalog, an available            containerized indexing node to process the data; and        -   communicate, to the partition manager, an indexing node            identifier associated with the available containerized            indexing node, wherein the partition manager communicates            the data to the available containerized indexing node based            on the indexing node identifier, wherein the available            containerized indexing node processes the data and stores            results in one or more data stores.

Additional embodiments of the present disclosure can be described inview of the following clauses:

-   -   Clause 1. A method, comprising:        -   receiving, at a containerized indexing node of a data intake            and query system, first data from a first partition manager            of the data intake and query system, the first data            associated with a first tenant identifier;        -   processing, by the containerized indexing node, the first            data, and storing first results of said processing the first            data in one or more first buckets associated with the first            tenant identifier;        -   receiving, at the containerized indexing node, second data            from a second partition manager of the data intake and query            system, the second data associated with a second tenant            identifier that is different from the first tenant            identifier; and        -   processing, by the containerized indexing node, the second            data, and storing second results of said processing the            second data in one or more second buckets associated with            the second tenant identifier.    -   Clause 2. The method of clause 1, wherein the first data is        received at the containerized indexing node based on a hash of        the first tenant identifier and a hash of an indexing node        identifier of the indexing node, and wherein the second data is        received at the containerized indexing node based on a hash of        the second tenant identifier and a hash of the indexing node        identifier of the indexing node.    -   Clause 3. The method of any of the previous clauses, wherein the        indexing node concurrently processes the first data and the        second data.    -   Clause 4. The method of any of the previous clauses, wherein the        first partition manager is the same as the second partition        manager.    -   Clause 5. The method of any of the previous clauses, wherein the        first partition manager is different from the second partition        manager.    -   Clause 6. The method of any of the previous clauses, wherein the        first data corresponds to a first partition of a stream of data        from an ingestion buffer of the data intake and query system,        and the second data corresponds to the first partition of the        stream of data from the ingestion buffer.    -   Clause 7. The method of any of the previous clauses, wherein the        first data corresponds to a first partition of a stream of data        from an ingestion buffer of the data intake and query system,        wherein the second data corresponds to a second partition of a        stream of data from the ingestion buffer.    -   Clause 8. The method of any of the previous clauses, wherein the        first tenant identifier uniquely identifies a first tenant from        a plurality of tenants associated with the data intake and query        system and the second tenant identifier uniquely identifies a        second tenant from the plurality of tenants.    -   Clause 9. The method of any of the previous clauses, wherein the        containerized indexing node receives the first data based on a        first indexing node identifier received by the first partition        manager from a resource monitor of the data intake and query        system, and wherein the containerized indexing node receives the        second data based on a second indexing node identifier received        from the resource monitor, wherein the first and second indexing        node identifiers identify the containerized indexing node.    -   Clause 10. The method of any of the previous clauses, wherein        the containerized indexing node receives the first data based on        a first indexing node identifier received by the first partition        manager from a resource monitor of the data intake and query        system, and wherein the containerized indexing node receives the        second data based on a second indexing node identifier received        from the resource monitor, wherein the first and second indexing        node identifiers identify the containerized indexing node,        wherein the resource monitor maintains a resource catalog        identifying a plurality of identifying containerized indexing        nodes instantiated in the data intake and query system including        the containerized indexing node.    -   Clause 11. The method of any of the previous clauses, wherein        the containerized indexing node receives the first data based on        a first indexing node identifier received by the first partition        manager from a resource monitor of the data intake and query        system, and wherein the containerized indexing node receives the        second data based on a second indexing node identifier received        from the resource monitor, wherein the first and second indexing        node identifiers identify the containerized indexing node,        wherein the resource monitor associates the first tenant        identifier with the containerized indexing node based on a hash        of the first tenant identifier, wherein the resource monitor        associates the second tenant identifier with the containerized        indexing node based on a hash of the second tenant identifier.    -   Clause 12. The method of any of the previous clauses, wherein        the containerized indexing node is a first containerized        indexing node and executes on a host system in a containerized        environment with one or more additional containerized indexing        nodes.    -   Clause 13. The method of any of the previous clauses, wherein        the first data comprises raw machine data that reflects activity        in an information processing environment and is produced by a        first component of the information processing environment.    -   Clause 14. The method of any of the previous clauses, wherein        the first data comprises raw machine data that reflects activity        in an information processing environment and is produced by a        first component of the information processing environment,        wherein the second data comprises raw machine data that reflects        activity in the information processing environment and is        produced by a second component of the information processing        environment.    -   Clause 15. The method of any of the previous clauses, wherein at        least one of the first data or the second data comprise raw        machine data.    -   Clause 16. The method of any of the previous clauses, wherein        the first data includes a reference to third data stored in a        data store, and wherein processing the first data comprises:        -   obtaining the third data stored in the data store based on            the reference; and        -   processing the third data to generate one or more events.    -   Clause 17. The method of any of the previous clauses, wherein        the first data includes a reference to third data stored in a        data store, wherein the first results include at least a portion        of the third data obtained from the data store.    -   Clause 18. The method of any of the previous clauses, wherein        the first data includes a first reference to third data stored        in a data store, wherein the second data includes a second        reference to fourth data stored in the data store, wherein        processing the first data comprises obtaining the third data        stored in the data store based on the first reference and        processing the third data to generate one or more first events,        and wherein processing the second data comprises obtaining the        fourth data stored in the data store based on the second        reference and processing the fourth data, wherein the first        results include at least a portion of the third data obtained        from the data store, wherein the second results include at least        a portion of the fourth data obtained from the data store.    -   Clause 19. The method of any of the previous clauses, wherein        the first data includes a reference to third data stored in a        data store, wherein the third data comprises raw machine data.    -   Clause 20. The method of any of the previous clauses, wherein        said processing the first data and the second data comprises        generating a plurality of events based on at least one of the        first data or the second data, wherein said storing the first        results and the second results comprises storing the plurality        of events in the one or more buckets.    -   Clause 21. The method of any of the previous clauses, wherein at        least one bucket of the one or more first buckets comprises a        plurality of first events corresponding to the first data and        first inverted index corresponding to the plurality of first        events, and wherein at least one bucket of the one or more        second buckets comprises a plurality of second events        corresponding to the second data and a second inverted index        corresponding to the plurality of second events.    -   Clause 22. The method of any of the previous clauses, wherein        the one or more first buckets and the one or more second buckets        are stored in a shared storage system.    -   Clause 23. The method of any of the previous clauses, further        comprising:    -   storing first location information of the one or more first        buckets in a data store catalog; and storing second location        information of the one or more second buckets in the data store        catalog, wherein the data store catalog is used during a query        to identify one or more buckets that include data that satisfies        at least a portion of the query.    -   Clause 24. The method of any of the previous clauses, wherein        the data intake and query system includes an ingestion buffer        that provides the first data to the first partition manager,        wherein the ingestion buffer includes a marker that indicates a        set of data that is to be made persistently available to an        indexing system that includes the containerized indexing node,        the method further comprising:    -   providing an indication to the ingestion buffer to update a        marker to change the set of data that is to be made persistently        available to the indexing system based on storing the second        results in a shared storage system. Clause 25. A computing        system of a data intake and query system, the computing system        comprising:        -   memory; and        -   one or more processing devices coupled to the memory and            configured to:            -   receive first data from a first partition manager of the                data intake and query system, the first data associated                with a first tenant identifier;            -   process the first data, and store first results of said                processing the first data in one or more first buckets                associated with the first tenant identifier;            -   receive second data from a second partition manager of                the data intake and query system, the second data                associated with a second tenant identifier that is                different from the first tenant identifier; and            -   process the second data, and store second results of                said processing the second data in one or more second                buckets associated with the second tenant identifier.    -   Clause 26. The computing system of clause 25, wherein the first        data is received based on a hash of the first tenant identifier        and a hash of an indexing node identifier of the indexing node,        and wherein the second data is received based on a hash of the        second tenant identifier and a hash of the indexing node        identifier of the indexing node.    -   Clause 27. The computing system of any of clause 25 or 26,        wherein the first data corresponds to a first partition of a        stream of data from an ingestion buffer of the data intake and        query system, wherein the second data corresponds to a second        partition of a stream of data from the ingestion buffer.    -   Clause 28. Non-transitory computer readable media comprising        computer-executable instructions that, when executed by a        computing system of a data intake and query system, cause the        computing system to:        -   receive first data from a first partition manager of the            data intake and query system, the first data associated with            a first tenant identifier;        -   process the first data, and store first results of said            processing the first data in one or more first buckets            associated with the first tenant identifier;        -   receive second data from a second partition manager of the            data intake and query system, the second data associated            with a second tenant identifier that is different from the            first tenant identifier; and        -   process the second data, and store second results of said            processing the second data in one or more second buckets            associated with the second tenant identifier.    -   Clause 29. The non-transitory computer readable media system of        clause 28, wherein the first data is received based on a hash of        the first tenant identifier and a hash of an indexing node        identifier of the indexing node, and wherein the second data is        received based on a hash of the second tenant identifier and a        hash of the indexing node identifier of the indexing node.    -   Clause 30. The non-transitory computer readable media system of        any of clause 28 or 29, wherein the first data corresponds to a        first partition of a stream of data from an ingestion buffer of        the data intake and query system, wherein the second data        corresponds to a second partition of a stream of data from the        ingestion buffer.

Additional embodiments of the present disclosure can be described inview of the following clauses:

-   -   Clause 1. A method, comprising:        -   receiving, at a containerized indexing node of a data intake            and query system, first data from a first partition manager            of the data intake and query system, the first data            associated with a first tenant identifier;        -   receiving, at the containerized indexing node, second data            from a second partition manager of the data intake and query            system, the second data associated with the first tenant            identifier; and        -   processing, by the containerized indexing node, the first            data and the second data, wherein the containerized indexing            node stores results of said processing in one or more            buckets associated with the first tenant identifier.    -   Clause 2. The method of clause 1, wherein the first data and the        second data are received at the containerized indexing node        based on a hash of the first tenant identifier and a hash of an        indexing node identifier of the indexing node.    -   Clause 3. The method of any of the previous clauses, further        comprising processing third data associated with a second tenant        identifier.    -   Clause 4. The method of any of the previous clauses, further        comprising processing third data associated with a second tenant        identifier,        -   wherein the first data and the second data are received at            the containerized indexing node based on a hash of the first            tenant identifier and a hash of an indexing node identifier            of the indexing node, and        -   wherein the third data is received at the containerized            indexing node based on a hash of the second tenant            identifier and a hash of the indexing node identifier of the            indexing node.    -   Clause 5. The method of any of the previous clauses, wherein the        one or more buckets are one or more first buckets, the methods        further comprising:        -   receiving, at the containerized indexing node, third data            from the first partition manager, the third data associated            with a second tenant identifier;        -   processing, by the containerized indexing node, the third            data; and        -   storing results of said processing the third data in the one            or more second buckets associated with the second tenant            identifier.    -   Clause 6. The method of any of the previous clauses, wherein the        first data corresponds to a first partition of a stream of data        from an ingestion buffer of the data intake and query system,        wherein the second data corresponds to a second partition of a        stream of data from the ingestion buffer.    -   Clause 7. The method of any of the previous clauses, wherein the        first tenant identifier uniquely identifies a particular tenant        from a plurality of tenants associated with the data intake and        query system.    -   Clause 8. The method of any of the previous clauses, wherein the        first partition manager communicates the first data to the        containerized indexing node based on an indexing node identifier        received by the first partition manager from a resource monitor        of the data intake and query system, wherein the second        partition manager communicates the second data to the        containerized indexing node based on the indexing node        identifier received from the resource monitor, wherein the        indexing node identifier identifies the containerized indexing        node.    -   Clause 9. The method of any of the previous clauses, wherein the        first partition manager communicates the first data to the        containerized indexing node based on an indexing node identifier        received by the first partition manager from a resource monitor        of the data intake and query system, wherein the indexing node        identifier identifies the containerized indexing node, wherein        the resource monitor maintains a resource catalog identifying a        plurality of identifying containerized indexing nodes        instantiated in the data intake and query system including the        containerized indexing node.    -   Clause 10. The method of any of the previous clauses, wherein        the first partition manager communicates the first data to the        containerized indexing node based on an indexing node identifier        received by the first partition manager from a resource monitor        of the data intake and query system, wherein the indexing node        identifier identifies the containerized indexing node, wherein        the resource monitor associates the first tenant identifier with        the containerized indexing node based on a hash of the first        tenant identifier. Clause 11. The method of any of the previous        clauses, wherein the containerized indexing node is a first        containerized indexing node and executes on a host system in a        containerized environment with one or more additional        containerized indexing nodes.    -   Clause 12. The method of any of the previous clauses, wherein        the first data comprises raw machine data that reflects activity        in an information processing environment and is produced by a        first component of the information processing environment.    -   Clause 13. The method of any of the previous clauses, wherein        the first data comprises raw machine data that reflects activity        in an information processing environment and is produced by a        first component of the information processing environment,        wherein the second data comprises raw machine data that reflects        activity in the information processing environment and is        produced by a second component of the information processing        environment.    -   Clause 14. The method of any of the previous clauses, wherein at        least one of the first data or the second data comprise raw        machine data.    -   Clause 15. The method of any of the previous clauses, wherein        the first data includes a reference to third data stored in a        data store, and wherein processing the first data comprises:        -   obtaining the third data stored in the data store based on            the reference; and        -   processing the third data to generate one or more events.    -   Clause 16. The method of any of the previous clauses, wherein        the first data includes a reference to third data stored in a        data store, wherein the results include at least a portion of        the third data obtained from the data store.    -   Clause 17. The method of any of the previous clauses, wherein        the first data includes a first reference to third data stored        in a data store and the second data includes a second reference        to fourth data stored in the data store, wherein processing the        first data comprises obtaining the third data stored in the data        store based on the first reference and processing the third data        to generate one or more first events, wherein processing the        second data comprises obtaining the fourth data stored in the        data store based on the second reference and processing the        fourth data to generate one or more second events, wherein the        results include at least a portion of at least one of the third        data or the fourth data.    -   Clause 18. The method of any of the previous clauses, wherein        the first data includes a reference to third data stored in a        data store, wherein the third data comprises raw machine data.    -   Clause 19. The method of any of the previous clauses, wherein at        least one of the one or more buckets includes at least a portion        of the first data and at least a portion of the second data.    -   Clause 20. The method of any of the previous clauses, wherein at        least one of the one or more buckets includes at least a portion        of third data referenced by the first data and at least a        portion of fourth data referenced by the second data.    -   Clause 21. The method of any of the previous clauses, wherein        each of the one or more buckets is a time series bucket.    -   Clause 22. The method of any of the previous clauses, wherein        said processing the first data and second data comprises        generating a plurality of events based on at least one of the        first data of the second data, wherein said storing the results        comprises storing the plurality of events in the one or more        buckets. Clause 23. The method of any of the previous clauses,        wherein the one or more buckets are stored in a shared storage        system.    -   Clause 24. The method of any of the previous clauses, wherein        the one or more buckets are stored in a shared storage system,        wherein the shared storage system is S3.    -   Clause 25. A computing system of a data intake and query system,        the computing system comprising:        -   memory; and        -   one or more processing devices coupled to the memory and            configured to:            -   receive first data from a first partition manager of the                data intake and query system, the first data associated                with a first tenant identifier;            -   receive second data from a second partition manager of                the data intake and query system, the second data                associated with the first tenant identifier; and            -   process the first data and the second data, wherein the                containerized indexing node stores results of said                processing in one or more buckets associated with the                first tenant identifier.    -   Clause 26. The computing system of clause 25, wherein the first        data and the second data are received at the containerized        indexing node based on a hash of the first tenant identifier and        a hash of an indexing node identifier of the indexing node.    -   Clause 27. The computing system of any of clauses 25 or 26,        wherein the first data corresponds to a first partition of a        stream of data from an ingestion buffer of the data intake and        query system, wherein the second data corresponds to a second        partition of a stream of data from the ingestion buffer.    -   Clause 28. Non-transitory computer readable media comprising        computer-executable instructions that, when executed by a        computing system of a data intake and query system, cause the        computing system to:        -   receive first data from a first partition manager of the            data intake and query system, the first data associated with            a first tenant identifier;        -   receive second data from a second partition manager of the            data intake and query system, the second data associated            with the first tenant identifier; and        -   process the first data and the second data, wherein the            containerized indexing node stores results of said            processing in one or more buckets associated with the first            tenant identifier.    -   Clause 29. The non-transitory computer readable media of clause        28, wherein the first data and the second data are received at        the containerized indexing node based on a hash of the first        tenant identifier and a hash of an indexing node identifier of        the indexing node.    -   Clause 30. The non-transitory computer readable media of any of        clauses 28 or 29, wherein the first data corresponds to a first        partition of a stream of data from an ingestion buffer of the        data intake and query system, wherein the second data        corresponds to a second partition of a stream of data from the        ingestion buffer.

6.0 Terminology

Computer programs typically comprise one or more instructions set atvarious times in various memory devices of a computing device, which,when read and executed by at least one processor, will cause a computingdevice to execute functions involving the disclosed techniques. In someembodiments, a carrier containing the aforementioned computer programproduct is provided. The carrier is one of an electronic signal, anoptical signal, a radio signal, or a non-transitory computer-readablestorage medium.

Any or all of the features and functions described above can be combinedwith each other, except to the extent it may be otherwise stated aboveor to the extent that any such embodiments may be incompatible by virtueof their function or structure, as will be apparent to persons ofordinary skill in the art. Unless contrary to physical possibility, itis envisioned that (i) the methods/steps described herein may beperformed in any sequence and/or in any combination, and (ii) thecomponents of respective embodiments may be combined in any manner.

Although the subject matter has been described in language specific tostructural features and/or acts, it is to be understood that the subjectmatter defined in the appended claims is not necessarily limited to thespecific features or acts described above. Rather, the specific featuresand acts described above are disclosed as examples of implementing theclaims, and other equivalent features and acts are intended to be withinthe scope of the claims.

Conditional language, such as, among others, “can,” “could,” “might,” or“may,” unless specifically stated otherwise, or otherwise understoodwithin the context as used, is generally intended to convey that certainembodiments include, while other embodiments do not include, certainfeatures, elements and/or steps. Thus, such conditional language is notgenerally intended to imply that features, elements and/or steps are inany way required for one or more embodiments or that one or moreembodiments necessarily include logic for deciding, with or without userinput or prompting, whether these features, elements and/or steps areincluded or are to be performed in any particular embodiment.Furthermore, use of “e.g.,” is to be interpreted as providing anon-limiting example and does not imply that two things are identical ornecessarily equate to each other.

Unless the context clearly requires otherwise, throughout thedescription and the claims, the words “comprise,” “comprising,” and thelike are to be construed in an inclusive sense, as opposed to anexclusive or exhaustive sense, i.e., in the sense of “including, but notlimited to.” As used herein, the terms “connected,” “coupled,” or anyvariant thereof means any connection or coupling, either direct orindirect, between two or more elements; the coupling or connectionbetween the elements can be physical, logical, or a combination thereof.Additionally, the words “herein,” “above,” “below,” and words of similarimport, when used in this application, refer to this application as awhole and not to any particular portions of this application. Where thecontext permits, words using the singular or plural number may alsoinclude the plural or singular number respectively. The word “or” inreference to a list of two or more items, covers all of the followinginterpretations of the word: any one of the items in the list, all ofthe items in the list, and any combination of the items in the list.Likewise the term “and/or” in reference to a list of two or more items,covers all of the following interpretations of the word: any one of theitems in the list, all of the items in the list, and any combination ofthe items in the list.

Conjunctive language such as the phrase “at least one of X, Y and Z,”unless specifically stated otherwise, is understood with the context asused in general to convey that an item, term, etc. may be either X, Y orZ, or any combination thereof. Thus, such conjunctive language is notgenerally intended to imply that certain embodiments require at leastone of X, at least one of Y and at least one of Z to each be present.Further, use of the phrase “at least one of X, Y or Z” as used ingeneral is to convey that an item, term, etc. may be either X, Y or Z,or any combination thereof.

In some embodiments, certain operations, acts, events, or functions ofany of the algorithms described herein can be performed in a differentsequence, can be added, merged, or left out altogether (e.g., not allare necessary for the practice of the algorithms). In certainembodiments, operations, acts, functions, or events can be performedconcurrently, e.g., through multi-threaded processing, interruptprocessing, or multiple processors or processor cores or on otherparallel architectures, rather than sequentially.

Systems and modules described herein may comprise software, firmware,hardware, or any combination(s) of software, firmware, or hardwaresuitable for the purposes described. Software and other modules mayreside and execute on servers, workstations, personal computers,computerized tablets, PDAs, and other computing devices suitable for thepurposes described herein. Software and other modules may be accessiblevia local computer memory, via a network, via a browser, or via othermeans suitable for the purposes described herein. Data structuresdescribed herein may comprise computer files, variables, programmingarrays, programming structures, or any electronic information storageschemes or methods, or any combinations thereof, suitable for thepurposes described herein. User interface elements described herein maycomprise elements from graphical user interfaces, interactive voiceresponse, command line interfaces, and other suitable interfaces.

Further, processing of the various components of the illustrated systemscan be distributed across multiple machines, networks, and othercomputing resources. Two or more components of a system can be combinedinto fewer components. Various components of the illustrated systems canbe implemented in one or more virtual machines or an isolated executionenvironment, rather than in dedicated computer hardware systems and/orcomputing devices. Likewise, the data repositories shown can representphysical and/or logical data storage, including, e.g., storage areanetworks or other distributed storage systems. Moreover, in someembodiments the connections between the components shown representpossible paths of data flow, rather than actual connections betweenhardware. While some examples of possible connections are shown, any ofthe subset of the components shown can communicate with any other subsetof components in various implementations.

Embodiments are also described above with reference to flow chartillustrations and/or block diagrams of methods, apparatus (systems) andcomputer program products. Each block of the flow chart illustrationsand/or block diagrams, and combinations of blocks in the flow chartillustrations and/or block diagrams, may be implemented by computerprogram instructions. Such instructions may be provided to a processorof a general purpose computer, special purpose computer,specially-equipped computer (e.g., comprising a high-performancedatabase server, a graphics subsystem, etc.) or other programmable dataprocessing apparatus to produce a machine, such that the instructions,which execute via the processor(s) of the computer or other programmabledata processing apparatus, create means for implementing the actsspecified in the flow chart and/or block diagram block or blocks. Thesecomputer program instructions may also be stored in a non-transitorycomputer-readable memory that can direct a computer or otherprogrammable data processing apparatus to operate in a particularmanner, such that the instructions stored in the computer-readablememory produce an article of manufacture including instruction meanswhich implement the acts specified in the flow chart and/or blockdiagram block or blocks. The computer program instructions may also beloaded to a computing device or other programmable data processingapparatus to cause operations to be performed on the computing device orother programmable apparatus to produce a computer implemented processsuch that the instructions which execute on the computing device orother programmable apparatus provide steps for implementing the actsspecified in the flow chart and/or block diagram block or blocks.

Any patents and applications and other references noted above, includingany that may be listed in accompanying filing papers, are incorporatedherein by reference. Aspects of the invention can be modified, ifnecessary, to employ the systems, functions, and concepts of the variousreferences described above to provide yet further implementations of theinvention. These and other changes can be made to the invention in lightof the above Detailed Description. While the above description describescertain examples of the invention, and describes the best modecontemplated, no matter how detailed the above appears in text, theinvention can be practiced in many ways. Details of the system may varyconsiderably in its specific implementation, while still beingencompassed by the invention disclosed herein. As noted above,particular terminology used when describing certain features or aspectsof the invention should not be taken to imply that the terminology isbeing redefined herein to be restricted to any specific characteristics,features, or aspects of the invention with which that terminology isassociated. In general, the terms used in the following claims shouldnot be construed to limit the invention to the specific examplesdisclosed in the specification, unless the above Detailed Descriptionsection explicitly defines such terms. Accordingly, the actual scope ofthe invention encompasses not only the disclosed examples, but also allequivalent ways of practicing or implementing the invention under theclaims.

To reduce the number of claims, certain aspects of the invention arepresented below in certain claim forms, but the applicant contemplatesother aspects of the invention in any number of claim forms. Forexample, while only one aspect of the invention is recited as ameans-plus-function claim under 35 U.S.C sec. 112(f) (AIA), otheraspects may likewise be embodied as a means-plus-function claim, or inother forms, such as being embodied in a computer-readable medium. Anyclaims intended to be treated under 35 U.S.C. § 112(f) will begin withthe words “means for,” but use of the term “for” in any other context isnot intended to invoke treatment under 35 U.S.C. § 112(f). Accordingly,the applicant reserves the right to pursue additional claims afterfiling this application, in either this application or in a continuingapplication.

What is claimed is:
 1. A method, comprising: receiving, at acontainerized indexing node of a data intake and query system, firstdata from a first partition manager of the data intake and query system,the first data associated with a first tenant identifier, wherein thecontainerized indexing node is dynamically allocated to process dataassociated with the first tenant identifier and data associated with asecond tenant identifier that is different from the first tenantidentifier; processing, by the containerized indexing node, the firstdata; assigning first results of said processing the first data to oneor more first buckets associated with the first tenant identifier basedat least in part on the first data being associated with the firsttenant identifier; storing the first results in the one or more firstbuckets; receiving, at the containerized indexing node, second data froma second partition manager of the data intake and query system, thesecond data associated with the second tenant identifier; processing, bythe containerized indexing node, the second data; assigning secondresults of said processing the second data to one or more second bucketsassociated with the second tenant identifier based at least in part onthe second data being associated with the second tenant identifier; andstoring the second results in the one or more second buckets.
 2. Themethod of claim 1, wherein the first data is received at thecontainerized indexing node based on a hash of the first tenantidentifier and a hash of an indexing node identifier of thecontainerized indexing node, and wherein the second data is received atthe containerized indexing node based on a hash of the second tenantidentifier and the hash of the indexing node identifier of thecontainerized indexing node.
 3. The method of claim 1, wherein thecontainerized indexing node concurrently processes the first data andthe second data.
 4. The method of claim 1, wherein the first partitionmanager is the same as the second partition manager.
 5. The method ofclaim 1, wherein the first partition manager is different from thesecond partition manager.
 6. The method of claim 1, wherein the firstdata corresponds to a first partition of a stream of data from aningestion buffer of the data intake and query system, and the seconddata corresponds to the first partition of the stream of data from theingestion buffer.
 7. The method of claim 1, wherein the first datacorresponds to a first partition of a stream of data from an ingestionbuffer of the data intake and query system, wherein the second datacorresponds to a second partition of a stream of data from the ingestionbuffer.
 8. The method of claim 1, wherein the first tenant identifieruniquely identifies a first tenant from a plurality of tenantsassociated with the data intake and query system and the second tenantidentifier uniquely identifies a second tenant from the plurality oftenants.
 9. The method of claim 1, wherein the containerized indexingnode receives the first data based on a first indexing node identifierreceived by the first partition manager from a resource monitor of thedata intake and query system, and wherein the containerized indexingnode receives the second data based on a second indexing node identifierreceived from the resource monitor, wherein the first and secondindexing node identifiers identify the containerized indexing node. 10.The method of claim 1, wherein the containerized indexing node receivesthe first data based on a first indexing node identifier received by thefirst partition manager from a resource monitor of the data intake andquery system, and wherein the containerized indexing node receives thesecond data based on a second indexing node identifier received from theresource monitor, wherein the first and second indexing node identifiersidentify the containerized indexing node, wherein the resource monitormaintains a resource catalog identifying a plurality of containerizedindexing nodes instantiated in the data intake and query systemincluding the containerized indexing node.
 11. The method of claim 1,wherein the containerized indexing node receives the first data based ona first indexing node identifier received by the first partition managerfrom a resource monitor of the data intake and query system, and whereinthe containerized indexing node receives the second data based on asecond indexing node identifier received from the resource monitor,wherein the first and second indexing node identifiers identify thecontainerized indexing node, wherein the resource monitor associates thefirst tenant identifier with the containerized indexing node based on ahash of the first tenant identifier, wherein the resource monitorassociates the second tenant identifier with the containerized indexingnode based on a hash of the second tenant identifier.
 12. The method ofclaim 1, wherein the containerized indexing node is a firstcontainerized indexing node and executes on a host system in acontainerized environment with one or more additional containerizedindexing nodes.
 13. The method of claim 1, wherein the first datacomprises raw machine data that reflects activity in an informationprocessing environment and is produced by a first component of theinformation processing environment.
 14. The method of claim 1, whereinthe first data comprises raw machine data that reflects activity in aninformation processing environment and is produced by a first componentof the information processing environment, wherein the second datacomprises raw machine data that reflects activity in the informationprocessing environment and is produced by a second component of theinformation processing environment.
 15. The method of claim 1, whereinat least one of the first data or the second data comprise raw machinedata.
 16. The method of claim 1, wherein the first data includes areference to third data stored in a data store, and wherein processingthe first data comprises: obtaining the third data stored in the datastore based on the reference; and processing the third data to generateone or more events.
 17. The method of claim 1, wherein the first dataincludes a reference to third data stored in a data store, wherein thefirst results include at least a portion of the third data obtained fromthe data store.
 18. The method of claim 1, wherein the first dataincludes a first reference to third data stored in a data store, whereinthe second data includes a second reference to fourth data stored in thedata store, wherein processing the first data comprises obtaining thethird data stored in the data store based on the first reference andprocessing the third data to generate one or more first events, andwherein processing the second data comprises obtaining the fourth datastored in the data store based on the second reference and processingthe fourth data, wherein the first results include at least a portion ofthe third data obtained from the data store, wherein the second resultsinclude at least a portion of the fourth data obtained from the datastore.
 19. The method of claim 1, wherein the first data includes areference to third data stored in a data store, wherein the third datacomprises raw machine data.
 20. The method of claim 1, wherein saidprocessing the first data and the second data comprises generating aplurality of events based on at least one of the first data or thesecond data, wherein said storing the first results and the secondresults comprises storing the plurality of events in the one or morefirst buckets and the one or more second buckets.
 21. The method ofclaim 1, wherein at least one bucket of the one or more first bucketscomprises a plurality of first events corresponding to the first dataand first inverted index corresponding to the plurality of first events,and wherein at least one bucket of the one or more second bucketscomprises a plurality of second events corresponding to the second dataand a second inverted index corresponding to the plurality of secondevents.
 22. The method of claim 1, wherein the one or more first bucketsand the one or more second buckets are stored in a shared storagesystem.
 23. The method of claim 1, further comprising: storing firstlocation information of the one or more first buckets in a data storecatalog; and storing second location information of the one or moresecond buckets in the data store catalog, wherein the data store catalogis used during a query to identify one or more buckets that include datathat satisfies at least a portion of the query.
 24. The method of claim1, wherein the data intake and query system includes an ingestion bufferthat provides the first data to the first partition manager, wherein theingestion buffer includes a marker that indicates a set of data that isto be made persistently available to an indexing system that includesthe containerized indexing node, the method further comprising:providing an indication to the ingestion buffer to update a marker tochange the set of data that is to be made persistently available to theindexing system based on storing the second results in a shared storagesystem.
 25. A computing system of a data intake and query system, thecomputing system comprising: memory; and one or more processing devicescoupled to the memory and configured to: receive first data from a firstpartition manager of the data intake and query system, the first dataassociated with a first tenant identifier, wherein the computing systemis dynamically allocated to process data associated with the firsttenant identifier and data associated with a second tenant identifierthat is different from the first tenant identifier; process the firstdata; assign first results of said processing the first data to one ormore first buckets associated with the first tenant identifier based atleast in part on the first data being associated with the first tenantidentifier; store the first results in the one or more first buckets;receive second data from a second partition manager of the data intakeand query system, the second data associated with the second tenantidentifier; process the second data; assign second results of saidprocessing the second data to one or more second buckets associated withthe second tenant identifier based at least in part on the second databeing associated with the second tenant identifier; and store the secondresults in the one or more second buckets.
 26. The computing system ofclaim 25, wherein the first data is received based on a hash of thefirst tenant identifier and a hash of an identifier of the computingsystem, and wherein the second data is received based on a hash of thesecond tenant identifier and the hash of the identifier of the computingsystem.
 27. The computing system of claim 25, wherein the first datacorresponds to a first partition of a stream of data from an ingestionbuffer of the data intake and query system, wherein the second datacorresponds to a second partition of a stream of data from the ingestionbuffer.
 28. Non-transitory computer readable media comprisingcomputer-executable instructions that, when executed by a computingsystem of a data intake and query system, cause the computing system to:receive first data from a first partition manager of the data intake andquery system, the first data associated with a first tenant identifier,wherein the computing system is dynamically allocated to process dataassociated with the first tenant identifier and data associated with asecond tenant identifier that is different from the first tenantidentifier; process the first data; assign first results of saidprocessing the first data to one or more first buckets associated withthe first tenant identifier based at least in part on the first databeing associated with the first tenant identifier; store the firstresults in the one or more first buckets; receive second data from asecond partition manager of the data intake and query system, the seconddata associated with the second tenant identifier; process the seconddata; assign second results of said processing the second data to one ormore second buckets associated with the second tenant identifier basedat least in part on the second data being associated with the secondtenant identifier; and store the second results in the one or moresecond buckets.
 29. The non-transitory computer readable media of claim28, wherein the first data is received based on a hash of the firsttenant identifier and a hash of an identifier of the computing system,and wherein the second data is received based on a hash of the secondtenant identifier and the hash of the identifier of the computingsystem.
 30. The non-transitory computer readable media of claim 28,wherein the first data corresponds to a first partition of a stream ofdata from an ingestion buffer of the data intake and query system,wherein the second data corresponds to a second partition of a stream ofdata from the ingestion buffer.